
// Generated from ./parser/grammar/FormalParser.g4 by ANTLR 4.8


#include <string>
#include <optional>
#include "../cyclone_parser_base.h"
#include "../syntax_error_formatter.hpp"



#include "FormalParser.h"


using boolean = bool;
using CppString = std::string;
using namespace cyclone::parser;


using namespace antlrcpp;
using namespace cyclone;
using namespace antlr4;

FormalParser::FormalParser(TokenStream *input) : CycloneParserBase(input) {
  SAFE_DELETE(_interpreter);
  _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
}

FormalParser::~FormalParser() {
  SAFE_DELETE(_interpreter);
}

std::string FormalParser::getGrammarFileName() const {
  return "FormalParser.g4";
}

const std::vector<std::string>& FormalParser::getRuleNames() const {
  return _ruleNames;
}

dfa::Vocabulary& FormalParser::getVocabulary() const {
  return _vocabulary;
}

/* parser definitions section */

//----------------- InputContext ------------------------------------------------------------------

FormalParser::InputContext::InputContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::ExpressionSequenceContext* FormalParser::InputContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

FormalParser::EosContext* FormalParser::InputContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}


size_t FormalParser::InputContext::getRuleIndex() const {
  return FormalParser::RuleInput;
}

size_t FormalParser::InputContext::getContextId() const {
  return FormalParser::ContextIdInput;
}


FormalParser::InputContext* FormalParser::input() {
  InputContext *_localctx = _tracker.createInstance<InputContext>(_ctx, getState());
  enterRule(_localctx, 0, FormalParser::RuleInput);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(244);
    expressionSequence();
    setState(245);
    eos();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VardeclContext ------------------------------------------------------------------

FormalParser::VardeclContext::VardeclContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::VariableDeclarationContext* FormalParser::VardeclContext::variableDeclaration() {
  return getRuleContext<FormalParser::VariableDeclarationContext>(0);
}

FormalParser::EosContext* FormalParser::VardeclContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}


size_t FormalParser::VardeclContext::getRuleIndex() const {
  return FormalParser::RuleVardecl;
}

size_t FormalParser::VardeclContext::getContextId() const {
  return FormalParser::ContextIdVardecl;
}


FormalParser::VardeclContext* FormalParser::vardecl() {
  VardeclContext *_localctx = _tracker.createInstance<VardeclContext>(_ctx, getState());
  enterRule(_localctx, 2, FormalParser::RuleVardecl);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(247);
    variableDeclaration();
    setState(248);
    eos();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OutputContext ------------------------------------------------------------------

FormalParser::OutputContext::OutputContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::AssignableContext* FormalParser::OutputContext::assignable() {
  return getRuleContext<FormalParser::AssignableContext>(0);
}

FormalParser::EosContext* FormalParser::OutputContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}


size_t FormalParser::OutputContext::getRuleIndex() const {
  return FormalParser::RuleOutput;
}

size_t FormalParser::OutputContext::getContextId() const {
  return FormalParser::ContextIdOutput;
}


FormalParser::OutputContext* FormalParser::output() {
  OutputContext *_localctx = _tracker.createInstance<OutputContext>(_ctx, getState());
  enterRule(_localctx, 4, FormalParser::RuleOutput);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(250);
    assignable();
    setState(251);
    eos();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PatternContext ------------------------------------------------------------------

FormalParser::PatternContext::PatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t FormalParser::PatternContext::getRuleIndex() const {
  return FormalParser::RulePattern;
}

size_t FormalParser::PatternContext::getContextId() const {
  return FormalParser::ContextIdPattern;
}

void FormalParser::PatternContext::copyFrom(PatternContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
  this->type = ctx->type;
}

//----------------- ArrayPatternContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ArrayPatternContext::OpenBracket() {
  return getToken(FormalParser::OpenBracket, 0);
}

tree::TerminalNode* FormalParser::ArrayPatternContext::CloseBracket() {
  return getToken(FormalParser::CloseBracket, 0);
}

FormalParser::ArrayPatternElementArrayListContext* FormalParser::ArrayPatternContext::arrayPatternElementArrayList() {
  return getRuleContext<FormalParser::ArrayPatternElementArrayListContext>(0);
}

FormalParser::TypeAnnotationContext* FormalParser::ArrayPatternContext::typeAnnotation() {
  return getRuleContext<FormalParser::TypeAnnotationContext>(0);
}


size_t FormalParser::ArrayPatternContext::getContextId() const {
  return FormalParser::ContextIdArrayPattern;
}

FormalParser::ArrayPatternContext::ArrayPatternContext(PatternContext *ctx) { copyFrom(ctx); }


//----------------- RestElementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::RestElementContext::Ellipsis() {
  return getToken(FormalParser::Ellipsis, 0);
}

FormalParser::PatternContext* FormalParser::RestElementContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

FormalParser::TypeAnnotationContext* FormalParser::RestElementContext::typeAnnotation() {
  return getRuleContext<FormalParser::TypeAnnotationContext>(0);
}


size_t FormalParser::RestElementContext::getContextId() const {
  return FormalParser::ContextIdRestElement;
}

FormalParser::RestElementContext::RestElementContext(PatternContext *ctx) { copyFrom(ctx); }


//----------------- ObjectPatternContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ObjectPatternContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::ObjectPatternContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::ObjectPatternElementArrayListContext* FormalParser::ObjectPatternContext::objectPatternElementArrayList() {
  return getRuleContext<FormalParser::ObjectPatternElementArrayListContext>(0);
}

FormalParser::TypeAnnotationContext* FormalParser::ObjectPatternContext::typeAnnotation() {
  return getRuleContext<FormalParser::TypeAnnotationContext>(0);
}


size_t FormalParser::ObjectPatternContext::getContextId() const {
  return FormalParser::ContextIdObjectPattern;
}

FormalParser::ObjectPatternContext::ObjectPatternContext(PatternContext *ctx) { copyFrom(ctx); }


//----------------- IdentifierPatternContext ------------------------------------------------------------------

FormalParser::IdentifierContext* FormalParser::IdentifierPatternContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}


size_t FormalParser::IdentifierPatternContext::getContextId() const {
  return FormalParser::ContextIdIdentifierPattern;
}

FormalParser::IdentifierPatternContext::IdentifierPatternContext(PatternContext *ctx) { copyFrom(ctx); }


FormalParser::PatternContext* FormalParser::pattern() {
  PatternContext *_localctx = _tracker.createInstance<PatternContext>(_ctx, getState());
  enterRule(_localctx, 6, FormalParser::RulePattern);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(284);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx)) {
    case 1: {
      _localctx = dynamic_cast<PatternContext *>(_tracker.createInstance<FormalParser::ObjectPatternContext>(_localctx));
      enterOuterAlt(_localctx, 1);
      setState(253);
      match(FormalParser::OpenBrace);
      setState(255);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 0, _ctx)) {
      case 1: {
        setState(254);
        dynamic_cast<ObjectPatternContext *>(_localctx)->properties_ = objectPatternElementArrayList();
        break;
      }

      }
      setState(257);
      match(FormalParser::CloseBrace);
      setState(260);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx)) {
      case 1: {
        setState(258);

        if (!(this->canBeFollowedByTypeAnnotation())) throw FailedPredicateException(this, "this->canBeFollowedByTypeAnnotation()");
        setState(259);
        dynamic_cast<ObjectPatternContext *>(_localctx)->typeAnnotation_ = typeAnnotation();
        break;
      }

      }

              dynamic_cast<ObjectPatternContext *>(_localctx)->type =  "ObjectPattern";
          
      break;
    }

    case 2: {
      _localctx = dynamic_cast<PatternContext *>(_tracker.createInstance<FormalParser::RestElementContext>(_localctx));
      enterOuterAlt(_localctx, 2);
      setState(263);
      match(FormalParser::Ellipsis);
      setState(264);
      dynamic_cast<RestElementContext *>(_localctx)->argument_ = pattern();
      setState(267);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx)) {
      case 1: {
        setState(265);

        if (!(this->canBeFollowedByTypeAnnotation())) throw FailedPredicateException(this, "this->canBeFollowedByTypeAnnotation()");
        setState(266);
        dynamic_cast<RestElementContext *>(_localctx)->typeAnnotation_ = typeAnnotation();
        break;
      }

      }

              dynamic_cast<RestElementContext *>(_localctx)->type =  "RestElement";
          
      break;
    }

    case 3: {
      _localctx = dynamic_cast<PatternContext *>(_tracker.createInstance<FormalParser::ArrayPatternContext>(_localctx));
      enterOuterAlt(_localctx, 3);
      setState(271);
      match(FormalParser::OpenBracket);
      setState(273);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx)) {
      case 1: {
        setState(272);
        dynamic_cast<ArrayPatternContext *>(_localctx)->elements_ = arrayPatternElementArrayList();
        break;
      }

      }
      setState(275);
      match(FormalParser::CloseBracket);
      setState(278);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx)) {
      case 1: {
        setState(276);

        if (!(this->canBeFollowedByTypeAnnotation())) throw FailedPredicateException(this, "this->canBeFollowedByTypeAnnotation()");
        setState(277);
        dynamic_cast<ArrayPatternContext *>(_localctx)->typeAnnotation_ = typeAnnotation();
        break;
      }

      }

              dynamic_cast<ArrayPatternContext *>(_localctx)->type =  "ArrayPattern";
          
      break;
    }

    case 4: {
      _localctx = dynamic_cast<PatternContext *>(_tracker.createInstance<FormalParser::IdentifierPatternContext>(_localctx));
      enterOuterAlt(_localctx, 4);
      setState(281);
      identifier();

              dynamic_cast<IdentifierPatternContext *>(_localctx)->type =  "Identifier";
          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignmentPatternContext ------------------------------------------------------------------

FormalParser::AssignmentPatternContext::AssignmentPatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::AssignmentOperatorContext* FormalParser::AssignmentPatternContext::assignmentOperator() {
  return getRuleContext<FormalParser::AssignmentOperatorContext>(0);
}

FormalParser::PatternContext* FormalParser::AssignmentPatternContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

FormalParser::ExpressionContext* FormalParser::AssignmentPatternContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::AssignmentPatternContext::getRuleIndex() const {
  return FormalParser::RuleAssignmentPattern;
}

size_t FormalParser::AssignmentPatternContext::getContextId() const {
  return FormalParser::ContextIdAssignmentPattern;
}


FormalParser::AssignmentPatternContext* FormalParser::assignmentPattern() {
  AssignmentPatternContext *_localctx = _tracker.createInstance<AssignmentPatternContext>(_ctx, getState());
  enterRule(_localctx, 8, FormalParser::RuleAssignmentPattern);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(286);
    dynamic_cast<AssignmentPatternContext *>(_localctx)->left_ = pattern();
    setState(287);
    assignmentOperator();
    setState(288);
    dynamic_cast<AssignmentPatternContext *>(_localctx)->right_ = expression(0);

            dynamic_cast<AssignmentPatternContext *>(_localctx)->type =  "AssignmentPattern";
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InitializerContext ------------------------------------------------------------------

FormalParser::InitializerContext::InitializerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::InitializerContext::Assign() {
  return getToken(FormalParser::Assign, 0);
}

FormalParser::ExpressionContext* FormalParser::InitializerContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::InitializerContext::getRuleIndex() const {
  return FormalParser::RuleInitializer;
}

size_t FormalParser::InitializerContext::getContextId() const {
  return FormalParser::ContextIdInitializer;
}


FormalParser::InitializerContext* FormalParser::initializer() {
  InitializerContext *_localctx = _tracker.createInstance<InitializerContext>(_ctx, getState());
  enterRule(_localctx, 10, FormalParser::RuleInitializer);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(291);
    match(FormalParser::Assign);
    setState(292);
    dynamic_cast<InitializerContext *>(_localctx)->expression_ = expression(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParameterListContext ------------------------------------------------------------------

FormalParser::ParameterListContext::ParameterListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::ParameterContext *> FormalParser::ParameterListContext::parameter() {
  return getRuleContexts<FormalParser::ParameterContext>();
}

FormalParser::ParameterContext* FormalParser::ParameterListContext::parameter(size_t i) {
  return getRuleContext<FormalParser::ParameterContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::ParameterListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::ParameterListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::ParameterListContext::getRuleIndex() const {
  return FormalParser::RuleParameterList;
}

size_t FormalParser::ParameterListContext::getContextId() const {
  return FormalParser::ContextIdParameterList;
}


FormalParser::ParameterListContext* FormalParser::parameterList() {
  ParameterListContext *_localctx = _tracker.createInstance<ParameterListContext>(_ctx, getState());
  enterRule(_localctx, 12, FormalParser::RuleParameterList);

  	    dynamic_cast<ParameterListContext *>(_localctx)->isArrayList =  true;
  		this->enterParameter();

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(294);
    parameter();
    setState(299);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::Comma) {
      setState(295);
      match(FormalParser::Comma);
      setState(296);
      parameter();
      setState(301);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }

    		this->leaveParameter();

   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParameterContext ------------------------------------------------------------------

FormalParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::AssignmentPatternContext* FormalParser::ParameterContext::assignmentPattern() {
  return getRuleContext<FormalParser::AssignmentPatternContext>(0);
}

FormalParser::PatternContext* FormalParser::ParameterContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}


size_t FormalParser::ParameterContext::getRuleIndex() const {
  return FormalParser::RuleParameter;
}

size_t FormalParser::ParameterContext::getContextId() const {
  return FormalParser::ContextIdParameter;
}


FormalParser::ParameterContext* FormalParser::parameter() {
  ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());
  enterRule(_localctx, 14, FormalParser::RuleParameter);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(306);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(304);
      assignmentPattern();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(305);
      pattern();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AdvancedParameterListContext ------------------------------------------------------------------

FormalParser::AdvancedParameterListContext::AdvancedParameterListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::SpreadElementContext* FormalParser::AdvancedParameterListContext::spreadElement() {
  return getRuleContext<FormalParser::SpreadElementContext>(0);
}

std::vector<FormalParser::AdvancedParameterContext *> FormalParser::AdvancedParameterListContext::advancedParameter() {
  return getRuleContexts<FormalParser::AdvancedParameterContext>();
}

FormalParser::AdvancedParameterContext* FormalParser::AdvancedParameterListContext::advancedParameter(size_t i) {
  return getRuleContext<FormalParser::AdvancedParameterContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::AdvancedParameterListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::AdvancedParameterListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::AdvancedParameterListContext::getRuleIndex() const {
  return FormalParser::RuleAdvancedParameterList;
}

size_t FormalParser::AdvancedParameterListContext::getContextId() const {
  return FormalParser::ContextIdAdvancedParameterList;
}


FormalParser::AdvancedParameterListContext* FormalParser::advancedParameterList() {
  AdvancedParameterListContext *_localctx = _tracker.createInstance<AdvancedParameterListContext>(_ctx, getState());
  enterRule(_localctx, 16, FormalParser::RuleAdvancedParameterList);

  	    dynamic_cast<AdvancedParameterListContext *>(_localctx)->isArrayList =  true;

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    setState(321);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(308);
      spreadElement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(309);
      advancedParameter();
      setState(314);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(310);
          match(FormalParser::Comma);
          setState(311);
          advancedParameter(); 
        }
        setState(316);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx);
      }
      setState(319);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FormalParser::Comma) {
        setState(317);
        match(FormalParser::Comma);
        setState(318);
        spreadElement();
      }
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RequiredParameterListContext ------------------------------------------------------------------

FormalParser::RequiredParameterListContext::RequiredParameterListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::RequiredParameterContext *> FormalParser::RequiredParameterListContext::requiredParameter() {
  return getRuleContexts<FormalParser::RequiredParameterContext>();
}

FormalParser::RequiredParameterContext* FormalParser::RequiredParameterListContext::requiredParameter(size_t i) {
  return getRuleContext<FormalParser::RequiredParameterContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::RequiredParameterListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::RequiredParameterListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::RequiredParameterListContext::getRuleIndex() const {
  return FormalParser::RuleRequiredParameterList;
}

size_t FormalParser::RequiredParameterListContext::getContextId() const {
  return FormalParser::ContextIdRequiredParameterList;
}


FormalParser::RequiredParameterListContext* FormalParser::requiredParameterList() {
  RequiredParameterListContext *_localctx = _tracker.createInstance<RequiredParameterListContext>(_ctx, getState());
  enterRule(_localctx, 18, FormalParser::RuleRequiredParameterList);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(323);
    requiredParameter();
    setState(328);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::Comma) {
      setState(324);
      match(FormalParser::Comma);
      setState(325);
      requiredParameter();
      setState(330);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AdvancedParameterContext ------------------------------------------------------------------

FormalParser::AdvancedParameterContext::AdvancedParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::RequiredParameterContext* FormalParser::AdvancedParameterContext::requiredParameter() {
  return getRuleContext<FormalParser::RequiredParameterContext>(0);
}

FormalParser::OptionalParameterContext* FormalParser::AdvancedParameterContext::optionalParameter() {
  return getRuleContext<FormalParser::OptionalParameterContext>(0);
}


size_t FormalParser::AdvancedParameterContext::getRuleIndex() const {
  return FormalParser::RuleAdvancedParameter;
}

size_t FormalParser::AdvancedParameterContext::getContextId() const {
  return FormalParser::ContextIdAdvancedParameter;
}


FormalParser::AdvancedParameterContext* FormalParser::advancedParameter() {
  AdvancedParameterContext *_localctx = _tracker.createInstance<AdvancedParameterContext>(_ctx, getState());
  enterRule(_localctx, 20, FormalParser::RuleAdvancedParameter);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(333);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(331);
      requiredParameter();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(332);
      optionalParameter();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionalParameterContext ------------------------------------------------------------------

FormalParser::OptionalParameterContext::OptionalParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::PatternContext* FormalParser::OptionalParameterContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

tree::TerminalNode* FormalParser::OptionalParameterContext::QuestionMark() {
  return getToken(FormalParser::QuestionMark, 0);
}

FormalParser::InitializerContext* FormalParser::OptionalParameterContext::initializer() {
  return getRuleContext<FormalParser::InitializerContext>(0);
}


size_t FormalParser::OptionalParameterContext::getRuleIndex() const {
  return FormalParser::RuleOptionalParameter;
}

size_t FormalParser::OptionalParameterContext::getContextId() const {
  return FormalParser::ContextIdOptionalParameter;
}


FormalParser::OptionalParameterContext* FormalParser::optionalParameter() {
  OptionalParameterContext *_localctx = _tracker.createInstance<OptionalParameterContext>(_ctx, getState());
  enterRule(_localctx, 22, FormalParser::RuleOptionalParameter);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(335);
    dynamic_cast<OptionalParameterContext *>(_localctx)->id_ = pattern();
    setState(338);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FormalParser::QuestionMark: {
        setState(336);
        match(FormalParser::QuestionMark);
        break;
      }

      case FormalParser::Assign: {
        setState(337);
        dynamic_cast<OptionalParameterContext *>(_localctx)->init_ = initializer();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RequiredParameterContext ------------------------------------------------------------------

FormalParser::RequiredParameterContext::RequiredParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::PatternContext* FormalParser::RequiredParameterContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

FormalParser::TypeAnnotationContext* FormalParser::RequiredParameterContext::typeAnnotation() {
  return getRuleContext<FormalParser::TypeAnnotationContext>(0);
}


size_t FormalParser::RequiredParameterContext::getRuleIndex() const {
  return FormalParser::RuleRequiredParameter;
}

size_t FormalParser::RequiredParameterContext::getContextId() const {
  return FormalParser::ContextIdRequiredParameter;
}


FormalParser::RequiredParameterContext* FormalParser::requiredParameter() {
  RequiredParameterContext *_localctx = _tracker.createInstance<RequiredParameterContext>(_ctx, getState());
  enterRule(_localctx, 24, FormalParser::RuleRequiredParameter);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(340);
    dynamic_cast<RequiredParameterContext *>(_localctx)->id_ = pattern();
    setState(342);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Colon) {
      setState(341);
      dynamic_cast<RequiredParameterContext *>(_localctx)->typeAnnotation_ = typeAnnotation();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AccessibilityModifierContext ------------------------------------------------------------------

FormalParser::AccessibilityModifierContext::AccessibilityModifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::AccessibilityModifierContext::Public() {
  return getToken(FormalParser::Public, 0);
}

tree::TerminalNode* FormalParser::AccessibilityModifierContext::Private() {
  return getToken(FormalParser::Private, 0);
}

tree::TerminalNode* FormalParser::AccessibilityModifierContext::Protected() {
  return getToken(FormalParser::Protected, 0);
}


size_t FormalParser::AccessibilityModifierContext::getRuleIndex() const {
  return FormalParser::RuleAccessibilityModifier;
}

size_t FormalParser::AccessibilityModifierContext::getContextId() const {
  return FormalParser::ContextIdAccessibilityModifier;
}


FormalParser::AccessibilityModifierContext* FormalParser::accessibilityModifier() {
  AccessibilityModifierContext *_localctx = _tracker.createInstance<AccessibilityModifierContext>(_ctx, getState());
  enterRule(_localctx, 26, FormalParser::RuleAccessibilityModifier);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(350);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FormalParser::Public: {
        enterOuterAlt(_localctx, 1);
        setState(344);
        match(FormalParser::Public);
         dynamic_cast<AccessibilityModifierContext *>(_localctx)->type =  "Public";
        break;
      }

      case FormalParser::Private: {
        enterOuterAlt(_localctx, 2);
        setState(346);
        match(FormalParser::Private);
         dynamic_cast<AccessibilityModifierContext *>(_localctx)->type =  "Private" ;
        break;
      }

      case FormalParser::Protected: {
        enterOuterAlt(_localctx, 3);
        setState(348);
        match(FormalParser::Protected);
         dynamic_cast<AccessibilityModifierContext *>(_localctx)->type =  "Protected" ;
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InterfaceExtendsClauseContext ------------------------------------------------------------------

FormalParser::InterfaceExtendsClauseContext::InterfaceExtendsClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::InterfaceExtendsClauseContext::Extends() {
  return getToken(FormalParser::Extends, 0);
}

FormalParser::ClassOrInterfaceTypeListContext* FormalParser::InterfaceExtendsClauseContext::classOrInterfaceTypeList() {
  return getRuleContext<FormalParser::ClassOrInterfaceTypeListContext>(0);
}


size_t FormalParser::InterfaceExtendsClauseContext::getRuleIndex() const {
  return FormalParser::RuleInterfaceExtendsClause;
}

size_t FormalParser::InterfaceExtendsClauseContext::getContextId() const {
  return FormalParser::ContextIdInterfaceExtendsClause;
}


FormalParser::InterfaceExtendsClauseContext* FormalParser::interfaceExtendsClause() {
  InterfaceExtendsClauseContext *_localctx = _tracker.createInstance<InterfaceExtendsClauseContext>(_ctx, getState());
  enterRule(_localctx, 28, FormalParser::RuleInterfaceExtendsClause);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(352);
    match(FormalParser::Extends);
    setState(353);
    classOrInterfaceTypeList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassOrInterfaceTypeListContext ------------------------------------------------------------------

FormalParser::ClassOrInterfaceTypeListContext::ClassOrInterfaceTypeListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::TypeNameContext *> FormalParser::ClassOrInterfaceTypeListContext::typeName() {
  return getRuleContexts<FormalParser::TypeNameContext>();
}

FormalParser::TypeNameContext* FormalParser::ClassOrInterfaceTypeListContext::typeName(size_t i) {
  return getRuleContext<FormalParser::TypeNameContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::ClassOrInterfaceTypeListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::ClassOrInterfaceTypeListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::ClassOrInterfaceTypeListContext::getRuleIndex() const {
  return FormalParser::RuleClassOrInterfaceTypeList;
}

size_t FormalParser::ClassOrInterfaceTypeListContext::getContextId() const {
  return FormalParser::ContextIdClassOrInterfaceTypeList;
}


FormalParser::ClassOrInterfaceTypeListContext* FormalParser::classOrInterfaceTypeList() {
  ClassOrInterfaceTypeListContext *_localctx = _tracker.createInstance<ClassOrInterfaceTypeListContext>(_ctx, getState());
  enterRule(_localctx, 30, FormalParser::RuleClassOrInterfaceTypeList);

  	    dynamic_cast<ClassOrInterfaceTypeListContext *>(_localctx)->isArrayList =  true;

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(355);
    typeName();
    setState(360);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::Comma) {
      setState(356);
      match(FormalParser::Comma);
      setState(357);
      typeName();
      setState(362);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumDeclarationContext ------------------------------------------------------------------

FormalParser::EnumDeclarationContext::EnumDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::EnumDeclarationContext::Enum() {
  return getToken(FormalParser::Enum, 0);
}

tree::TerminalNode* FormalParser::EnumDeclarationContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::EnumDeclarationContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::IdentifierContext* FormalParser::EnumDeclarationContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

tree::TerminalNode* FormalParser::EnumDeclarationContext::Const() {
  return getToken(FormalParser::Const, 0);
}

FormalParser::EnumBodyContext* FormalParser::EnumDeclarationContext::enumBody() {
  return getRuleContext<FormalParser::EnumBodyContext>(0);
}


size_t FormalParser::EnumDeclarationContext::getRuleIndex() const {
  return FormalParser::RuleEnumDeclaration;
}

size_t FormalParser::EnumDeclarationContext::getContextId() const {
  return FormalParser::ContextIdEnumDeclaration;
}


FormalParser::EnumDeclarationContext* FormalParser::enumDeclaration() {
  EnumDeclarationContext *_localctx = _tracker.createInstance<EnumDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 32, FormalParser::RuleEnumDeclaration);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(364);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Const) {
      setState(363);
      match(FormalParser::Const);
    }
    setState(366);
    match(FormalParser::Enum);
    setState(367);
    dynamic_cast<EnumDeclarationContext *>(_localctx)->id_ = identifier();
    setState(368);
    match(FormalParser::OpenBrace);
    setState(370);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {
    case 1: {
      setState(369);
      dynamic_cast<EnumDeclarationContext *>(_localctx)->body_ = enumBody();
      break;
    }

    }
    setState(372);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumBodyContext ------------------------------------------------------------------

FormalParser::EnumBodyContext::EnumBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::EnumMemberListContext* FormalParser::EnumBodyContext::enumMemberList() {
  return getRuleContext<FormalParser::EnumMemberListContext>(0);
}

tree::TerminalNode* FormalParser::EnumBodyContext::Comma() {
  return getToken(FormalParser::Comma, 0);
}


size_t FormalParser::EnumBodyContext::getRuleIndex() const {
  return FormalParser::RuleEnumBody;
}

size_t FormalParser::EnumBodyContext::getContextId() const {
  return FormalParser::ContextIdEnumBody;
}


FormalParser::EnumBodyContext* FormalParser::enumBody() {
  EnumBodyContext *_localctx = _tracker.createInstance<EnumBodyContext>(_ctx, getState());
  enterRule(_localctx, 34, FormalParser::RuleEnumBody);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(374);
    dynamic_cast<EnumBodyContext *>(_localctx)->memberList_ = enumMemberList();
    setState(376);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Comma) {
      setState(375);
      match(FormalParser::Comma);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumMemberListContext ------------------------------------------------------------------

FormalParser::EnumMemberListContext::EnumMemberListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::EnumMemberContext *> FormalParser::EnumMemberListContext::enumMember() {
  return getRuleContexts<FormalParser::EnumMemberContext>();
}

FormalParser::EnumMemberContext* FormalParser::EnumMemberListContext::enumMember(size_t i) {
  return getRuleContext<FormalParser::EnumMemberContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::EnumMemberListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::EnumMemberListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::EnumMemberListContext::getRuleIndex() const {
  return FormalParser::RuleEnumMemberList;
}

size_t FormalParser::EnumMemberListContext::getContextId() const {
  return FormalParser::ContextIdEnumMemberList;
}


FormalParser::EnumMemberListContext* FormalParser::enumMemberList() {
  EnumMemberListContext *_localctx = _tracker.createInstance<EnumMemberListContext>(_ctx, getState());
  enterRule(_localctx, 36, FormalParser::RuleEnumMemberList);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(378);
    enumMember();
    setState(383);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(379);
        match(FormalParser::Comma);
        setState(380);
        enumMember(); 
      }
      setState(385);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumMemberContext ------------------------------------------------------------------

FormalParser::EnumMemberContext::EnumMemberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::PropertyNameContext* FormalParser::EnumMemberContext::propertyName() {
  return getRuleContext<FormalParser::PropertyNameContext>(0);
}

tree::TerminalNode* FormalParser::EnumMemberContext::Assign() {
  return getToken(FormalParser::Assign, 0);
}

FormalParser::ExpressionContext* FormalParser::EnumMemberContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::EnumMemberContext::getRuleIndex() const {
  return FormalParser::RuleEnumMember;
}

size_t FormalParser::EnumMemberContext::getContextId() const {
  return FormalParser::ContextIdEnumMember;
}


FormalParser::EnumMemberContext* FormalParser::enumMember() {
  EnumMemberContext *_localctx = _tracker.createInstance<EnumMemberContext>(_ctx, getState());
  enterRule(_localctx, 38, FormalParser::RuleEnumMember);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(386);
    propertyName();
    setState(389);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Assign) {
      setState(387);
      match(FormalParser::Assign);
      setState(388);
      expression(0);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ImportAliasDeclarationContext ------------------------------------------------------------------

FormalParser::ImportAliasDeclarationContext::ImportAliasDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ImportAliasDeclarationContext::Assign() {
  return getToken(FormalParser::Assign, 0);
}

tree::TerminalNode* FormalParser::ImportAliasDeclarationContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}

FormalParser::IdentifierContext* FormalParser::ImportAliasDeclarationContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::QualifiedNameContext* FormalParser::ImportAliasDeclarationContext::qualifiedName() {
  return getRuleContext<FormalParser::QualifiedNameContext>(0);
}


size_t FormalParser::ImportAliasDeclarationContext::getRuleIndex() const {
  return FormalParser::RuleImportAliasDeclaration;
}

size_t FormalParser::ImportAliasDeclarationContext::getContextId() const {
  return FormalParser::ContextIdImportAliasDeclaration;
}


FormalParser::ImportAliasDeclarationContext* FormalParser::importAliasDeclaration() {
  ImportAliasDeclarationContext *_localctx = _tracker.createInstance<ImportAliasDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 40, FormalParser::RuleImportAliasDeclaration);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(391);
    dynamic_cast<ImportAliasDeclarationContext *>(_localctx)->id_ = identifier();
    setState(392);
    match(FormalParser::Assign);
    setState(393);
    dynamic_cast<ImportAliasDeclarationContext *>(_localctx)->namespaceName_ = qualifiedName();
    setState(394);
    match(FormalParser::SemiColon);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProgramContext ------------------------------------------------------------------

FormalParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ProgramContext::EOF() {
  return getToken(FormalParser::EOF, 0);
}

FormalParser::SourceArrayListContext* FormalParser::ProgramContext::sourceArrayList() {
  return getRuleContext<FormalParser::SourceArrayListContext>(0);
}


size_t FormalParser::ProgramContext::getRuleIndex() const {
  return FormalParser::RuleProgram;
}

size_t FormalParser::ProgramContext::getContextId() const {
  return FormalParser::ContextIdProgram;
}


FormalParser::ProgramContext* FormalParser::program() {
  ProgramContext *_localctx = _tracker.createInstance<ProgramContext>(_ctx, getState());
  enterRule(_localctx, 42, FormalParser::RuleProgram);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(397);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx)) {
    case 1: {
      setState(396);
      dynamic_cast<ProgramContext *>(_localctx)->body_ = sourceArrayList();
      break;
    }

    }
    setState(399);
    match(FormalParser::EOF);
     
            dynamic_cast<ProgramContext *>(_localctx)->type =  "Program"; dynamic_cast<ProgramContext *>(_localctx)->sourceType =  "module"; 
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceElementContext ------------------------------------------------------------------

FormalParser::SourceElementContext::SourceElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::StatementContext* FormalParser::SourceElementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}

tree::TerminalNode* FormalParser::SourceElementContext::Export() {
  return getToken(FormalParser::Export, 0);
}


size_t FormalParser::SourceElementContext::getRuleIndex() const {
  return FormalParser::RuleSourceElement;
}

size_t FormalParser::SourceElementContext::getContextId() const {
  return FormalParser::ContextIdSourceElement;
}


FormalParser::SourceElementContext* FormalParser::sourceElement() {
  SourceElementContext *_localctx = _tracker.createInstance<SourceElementContext>(_ctx, getState());
  enterRule(_localctx, 44, FormalParser::RuleSourceElement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(403);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx)) {
    case 1: {
      setState(402);
      match(FormalParser::Export);
      break;
    }

    }
    setState(405);
    dynamic_cast<SourceElementContext *>(_localctx)->statement_ = statement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementContext ------------------------------------------------------------------

FormalParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t FormalParser::StatementContext::getRuleIndex() const {
  return FormalParser::RuleStatement;
}

size_t FormalParser::StatementContext::getContextId() const {
  return FormalParser::ContextIdStatement;
}

void FormalParser::StatementContext::copyFrom(StatementContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
  this->type = ctx->type;
}

//----------------- ExportStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ExportStatementContext::Export() {
  return getToken(FormalParser::Export, 0);
}

FormalParser::FromBlockContext* FormalParser::ExportStatementContext::fromBlock() {
  return getRuleContext<FormalParser::FromBlockContext>(0);
}

FormalParser::StatementContext* FormalParser::ExportStatementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}

tree::TerminalNode* FormalParser::ExportStatementContext::Default() {
  return getToken(FormalParser::Default, 0);
}


size_t FormalParser::ExportStatementContext::getContextId() const {
  return FormalParser::ContextIdExportStatement;
}

FormalParser::ExportStatementContext::ExportStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- TSEnumDeclarationContext ------------------------------------------------------------------

FormalParser::EnumDeclarationContext* FormalParser::TSEnumDeclarationContext::enumDeclaration() {
  return getRuleContext<FormalParser::EnumDeclarationContext>(0);
}


size_t FormalParser::TSEnumDeclarationContext::getContextId() const {
  return FormalParser::ContextIdTSEnumDeclaration;
}

FormalParser::TSEnumDeclarationContext::TSEnumDeclarationContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- EmptyStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::EmptyStatementContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}


size_t FormalParser::EmptyStatementContext::getContextId() const {
  return FormalParser::ContextIdEmptyStatement;
}

FormalParser::EmptyStatementContext::EmptyStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- BlockStatementContext ------------------------------------------------------------------

FormalParser::BraceBlockContext* FormalParser::BlockStatementContext::braceBlock() {
  return getRuleContext<FormalParser::BraceBlockContext>(0);
}


size_t FormalParser::BlockStatementContext::getContextId() const {
  return FormalParser::ContextIdBlockStatement;
}

FormalParser::BlockStatementContext::BlockStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- ImportStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ImportStatementContext::Import() {
  return getToken(FormalParser::Import, 0);
}

FormalParser::FromBlockContext* FormalParser::ImportStatementContext::fromBlock() {
  return getRuleContext<FormalParser::FromBlockContext>(0);
}

FormalParser::ImportAliasDeclarationContext* FormalParser::ImportStatementContext::importAliasDeclaration() {
  return getRuleContext<FormalParser::ImportAliasDeclarationContext>(0);
}


size_t FormalParser::ImportStatementContext::getContextId() const {
  return FormalParser::ContextIdImportStatement;
}

FormalParser::ImportStatementContext::ImportStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- WhileStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::WhileStatementContext::While() {
  return getToken(FormalParser::While, 0);
}

tree::TerminalNode* FormalParser::WhileStatementContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::WhileStatementContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ExpressionSequenceContext* FormalParser::WhileStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

FormalParser::StatementContext* FormalParser::WhileStatementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}


size_t FormalParser::WhileStatementContext::getContextId() const {
  return FormalParser::ContextIdWhileStatement;
}

FormalParser::WhileStatementContext::WhileStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- WithStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::WithStatementContext::With() {
  return getToken(FormalParser::With, 0);
}

tree::TerminalNode* FormalParser::WithStatementContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::WithStatementContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ExpressionSequenceContext* FormalParser::WithStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

FormalParser::StatementContext* FormalParser::WithStatementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}


size_t FormalParser::WithStatementContext::getContextId() const {
  return FormalParser::ContextIdWithStatement;
}

FormalParser::WithStatementContext::WithStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- BreakStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::BreakStatementContext::Break() {
  return getToken(FormalParser::Break, 0);
}

FormalParser::EosContext* FormalParser::BreakStatementContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}

FormalParser::IdentifierContext* FormalParser::BreakStatementContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}


size_t FormalParser::BreakStatementContext::getContextId() const {
  return FormalParser::ContextIdBreakStatement;
}

FormalParser::BreakStatementContext::BreakStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- IfStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::IfStatementContext::If() {
  return getToken(FormalParser::If, 0);
}

tree::TerminalNode* FormalParser::IfStatementContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::IfStatementContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ExpressionSequenceContext* FormalParser::IfStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

std::vector<FormalParser::StatementContext *> FormalParser::IfStatementContext::statement() {
  return getRuleContexts<FormalParser::StatementContext>();
}

FormalParser::StatementContext* FormalParser::IfStatementContext::statement(size_t i) {
  return getRuleContext<FormalParser::StatementContext>(i);
}

tree::TerminalNode* FormalParser::IfStatementContext::Else() {
  return getToken(FormalParser::Else, 0);
}


size_t FormalParser::IfStatementContext::getContextId() const {
  return FormalParser::ContextIdIfStatement;
}

FormalParser::IfStatementContext::IfStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- SwitchStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::SwitchStatementContext::Switch() {
  return getToken(FormalParser::Switch, 0);
}

tree::TerminalNode* FormalParser::SwitchStatementContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::SwitchStatementContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ExpressionSequenceContext* FormalParser::SwitchStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

FormalParser::SwitchCaseListContext* FormalParser::SwitchStatementContext::switchCaseList() {
  return getRuleContext<FormalParser::SwitchCaseListContext>(0);
}


size_t FormalParser::SwitchStatementContext::getContextId() const {
  return FormalParser::ContextIdSwitchStatement;
}

FormalParser::SwitchStatementContext::SwitchStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- TSModuleDeclarationContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::TSModuleDeclarationContext::Namespace() {
  return getToken(FormalParser::Namespace, 0);
}

tree::TerminalNode* FormalParser::TSModuleDeclarationContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::TSModuleDeclarationContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::IdentifierContext* FormalParser::TSModuleDeclarationContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::QualifiedNameContext* FormalParser::TSModuleDeclarationContext::qualifiedName() {
  return getRuleContext<FormalParser::QualifiedNameContext>(0);
}

FormalParser::StatementListContext* FormalParser::TSModuleDeclarationContext::statementList() {
  return getRuleContext<FormalParser::StatementListContext>(0);
}


size_t FormalParser::TSModuleDeclarationContext::getContextId() const {
  return FormalParser::ContextIdTSModuleDeclaration;
}

FormalParser::TSModuleDeclarationContext::TSModuleDeclarationContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- LabeledStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::LabeledStatementContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

FormalParser::IdentifierContext* FormalParser::LabeledStatementContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::StatementContext* FormalParser::LabeledStatementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}


size_t FormalParser::LabeledStatementContext::getContextId() const {
  return FormalParser::ContextIdLabeledStatement;
}

FormalParser::LabeledStatementContext::LabeledStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- TryStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::TryStatementContext::Try() {
  return getToken(FormalParser::Try, 0);
}

FormalParser::BraceBlockContext* FormalParser::TryStatementContext::braceBlock() {
  return getRuleContext<FormalParser::BraceBlockContext>(0);
}

FormalParser::CatchProductionContext* FormalParser::TryStatementContext::catchProduction() {
  return getRuleContext<FormalParser::CatchProductionContext>(0);
}

FormalParser::FinallyProductionContext* FormalParser::TryStatementContext::finallyProduction() {
  return getRuleContext<FormalParser::FinallyProductionContext>(0);
}


size_t FormalParser::TryStatementContext::getContextId() const {
  return FormalParser::ContextIdTryStatement;
}

FormalParser::TryStatementContext::TryStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- ExpressionStatementContext ------------------------------------------------------------------

FormalParser::ExpressionSequenceContext* FormalParser::ExpressionStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

tree::TerminalNode* FormalParser::ExpressionStatementContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}


size_t FormalParser::ExpressionStatementContext::getContextId() const {
  return FormalParser::ContextIdExpressionStatement;
}

FormalParser::ExpressionStatementContext::ExpressionStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- ReturnStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ReturnStatementContext::Return() {
  return getToken(FormalParser::Return, 0);
}

FormalParser::EosContext* FormalParser::ReturnStatementContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}

FormalParser::ExpressionContext* FormalParser::ReturnStatementContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::ReturnStatementContext::getContextId() const {
  return FormalParser::ContextIdReturnStatement;
}

FormalParser::ReturnStatementContext::ReturnStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- ThrowStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ThrowStatementContext::Throw() {
  return getToken(FormalParser::Throw, 0);
}

FormalParser::EosContext* FormalParser::ThrowStatementContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}

FormalParser::ExpressionSequenceContext* FormalParser::ThrowStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}


size_t FormalParser::ThrowStatementContext::getContextId() const {
  return FormalParser::ContextIdThrowStatement;
}

FormalParser::ThrowStatementContext::ThrowStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- TSTypeAliasDeclarationContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::TSTypeAliasDeclarationContext::TypeAlias() {
  return getToken(FormalParser::TypeAlias, 0);
}

tree::TerminalNode* FormalParser::TSTypeAliasDeclarationContext::Assign() {
  return getToken(FormalParser::Assign, 0);
}

FormalParser::EosContext* FormalParser::TSTypeAliasDeclarationContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}

FormalParser::IdentifierContext* FormalParser::TSTypeAliasDeclarationContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::Type_Context* FormalParser::TSTypeAliasDeclarationContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}


size_t FormalParser::TSTypeAliasDeclarationContext::getContextId() const {
  return FormalParser::ContextIdTSTypeAliasDeclaration;
}

FormalParser::TSTypeAliasDeclarationContext::TSTypeAliasDeclarationContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- ForStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ForStatementContext::For() {
  return getToken(FormalParser::For, 0);
}

tree::TerminalNode* FormalParser::ForStatementContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

std::vector<tree::TerminalNode *> FormalParser::ForStatementContext::SemiColon() {
  return getTokens(FormalParser::SemiColon);
}

tree::TerminalNode* FormalParser::ForStatementContext::SemiColon(size_t i) {
  return getToken(FormalParser::SemiColon, i);
}

tree::TerminalNode* FormalParser::ForStatementContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::StatementContext* FormalParser::ForStatementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}

FormalParser::ForInitStatementContext* FormalParser::ForStatementContext::forInitStatement() {
  return getRuleContext<FormalParser::ForInitStatementContext>(0);
}

std::vector<FormalParser::ExpressionSequenceContext *> FormalParser::ForStatementContext::expressionSequence() {
  return getRuleContexts<FormalParser::ExpressionSequenceContext>();
}

FormalParser::ExpressionSequenceContext* FormalParser::ForStatementContext::expressionSequence(size_t i) {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(i);
}


size_t FormalParser::ForStatementContext::getContextId() const {
  return FormalParser::ContextIdForStatement;
}

FormalParser::ForStatementContext::ForStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- DoWhileStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::DoWhileStatementContext::Do() {
  return getToken(FormalParser::Do, 0);
}

tree::TerminalNode* FormalParser::DoWhileStatementContext::While() {
  return getToken(FormalParser::While, 0);
}

tree::TerminalNode* FormalParser::DoWhileStatementContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::DoWhileStatementContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::EosContext* FormalParser::DoWhileStatementContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}

FormalParser::StatementContext* FormalParser::DoWhileStatementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}

FormalParser::ExpressionSequenceContext* FormalParser::DoWhileStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}


size_t FormalParser::DoWhileStatementContext::getContextId() const {
  return FormalParser::ContextIdDoWhileStatement;
}

FormalParser::DoWhileStatementContext::DoWhileStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- ForInStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ForInStatementContext::For() {
  return getToken(FormalParser::For, 0);
}

tree::TerminalNode* FormalParser::ForInStatementContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::ForInStatementContext::In() {
  return getToken(FormalParser::In, 0);
}

tree::TerminalNode* FormalParser::ForInStatementContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::BaseForXStatementContext* FormalParser::ForInStatementContext::baseForXStatement() {
  return getRuleContext<FormalParser::BaseForXStatementContext>(0);
}

FormalParser::ExpressionSequenceContext* FormalParser::ForInStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

FormalParser::StatementContext* FormalParser::ForInStatementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}


size_t FormalParser::ForInStatementContext::getContextId() const {
  return FormalParser::ContextIdForInStatement;
}

FormalParser::ForInStatementContext::ForInStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- ContinueStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ContinueStatementContext::Continue() {
  return getToken(FormalParser::Continue, 0);
}

FormalParser::EosContext* FormalParser::ContinueStatementContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}

FormalParser::IdentifierContext* FormalParser::ContinueStatementContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}


size_t FormalParser::ContinueStatementContext::getContextId() const {
  return FormalParser::ContextIdContinueStatement;
}

FormalParser::ContinueStatementContext::ContinueStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- DebuggerStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::DebuggerStatementContext::Debugger() {
  return getToken(FormalParser::Debugger, 0);
}

FormalParser::EosContext* FormalParser::DebuggerStatementContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}


size_t FormalParser::DebuggerStatementContext::getContextId() const {
  return FormalParser::ContextIdDebuggerStatement;
}

FormalParser::DebuggerStatementContext::DebuggerStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- ForOfStatementContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ForOfStatementContext::For() {
  return getToken(FormalParser::For, 0);
}

tree::TerminalNode* FormalParser::ForOfStatementContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::ForOfStatementContext::Of() {
  return getToken(FormalParser::Of, 0);
}

tree::TerminalNode* FormalParser::ForOfStatementContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::BaseForXStatementContext* FormalParser::ForOfStatementContext::baseForXStatement() {
  return getRuleContext<FormalParser::BaseForXStatementContext>(0);
}

FormalParser::ExpressionSequenceContext* FormalParser::ForOfStatementContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

FormalParser::StatementContext* FormalParser::ForOfStatementContext::statement() {
  return getRuleContext<FormalParser::StatementContext>(0);
}


size_t FormalParser::ForOfStatementContext::getContextId() const {
  return FormalParser::ContextIdForOfStatement;
}

FormalParser::ForOfStatementContext::ForOfStatementContext(StatementContext *ctx) { copyFrom(ctx); }


//----------------- DeclarationStatementContext ------------------------------------------------------------------

FormalParser::DeclarationContext* FormalParser::DeclarationStatementContext::declaration() {
  return getRuleContext<FormalParser::DeclarationContext>(0);
}


size_t FormalParser::DeclarationStatementContext::getContextId() const {
  return FormalParser::ContextIdDeclarationStatement;
}

FormalParser::DeclarationStatementContext::DeclarationStatementContext(StatementContext *ctx) { copyFrom(ctx); }


FormalParser::StatementContext* FormalParser::statement() {
  StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
  enterRule(_localctx, 46, FormalParser::RuleStatement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(587);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx)) {
    case 1: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::BlockStatementContext>(_localctx));
      enterOuterAlt(_localctx, 1);
      setState(407);
      braceBlock();


          
      break;
    }

    case 2: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ImportStatementContext>(_localctx));
      enterOuterAlt(_localctx, 2);
      setState(410);
      match(FormalParser::Import);
      setState(413);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 24, _ctx)) {
      case 1: {
        setState(411);
        fromBlock();
        break;
      }

      case 2: {
        setState(412);
        importAliasDeclaration();
        break;
      }

      }

              dynamic_cast<ImportStatementContext *>(_localctx)->type =  "ImportStatement";
          
      break;
    }

    case 3: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ExportStatementContext>(_localctx));
      enterOuterAlt(_localctx, 3);
      setState(417);
      match(FormalParser::Export);
      setState(419);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx)) {
      case 1: {
        setState(418);
        match(FormalParser::Default);
        break;
      }

      }
      setState(423);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx)) {
      case 1: {
        setState(421);
        fromBlock();
        break;
      }

      case 2: {
        setState(422);
        statement();
        break;
      }

      }

              dynamic_cast<ExportStatementContext *>(_localctx)->type =  "ExportStatement";
          
      break;
    }

    case 4: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::EmptyStatementContext>(_localctx));
      enterOuterAlt(_localctx, 4);
      setState(427);
      match(FormalParser::SemiColon);

              dynamic_cast<EmptyStatementContext *>(_localctx)->type =  "EmptyStatement";
          
      break;
    }

    case 5: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::TSModuleDeclarationContext>(_localctx));
      enterOuterAlt(_localctx, 5);
      setState(429);
      match(FormalParser::Namespace);
      setState(432);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
      case 1: {
        setState(430);
        identifier();
        break;
      }

      case 2: {
        setState(431);
        qualifiedName();
        break;
      }

      }
      setState(434);
      match(FormalParser::OpenBrace);
      setState(436);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx)) {
      case 1: {
        setState(435);
        dynamic_cast<TSModuleDeclarationContext *>(_localctx)->body_ = statementList();
        break;
      }

      }
      setState(438);
      match(FormalParser::CloseBrace);

              dynamic_cast<TSModuleDeclarationContext *>(_localctx)->type =  "TSModuleDeclaration";
          
      break;
    }

    case 6: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::IfStatementContext>(_localctx));
      enterOuterAlt(_localctx, 6);
      setState(441);
      match(FormalParser::If);
      setState(442);
      match(FormalParser::OpenParen);
      setState(443);
      dynamic_cast<IfStatementContext *>(_localctx)->test_ = expressionSequence();
      setState(444);
      match(FormalParser::CloseParen);
      setState(445);
      dynamic_cast<IfStatementContext *>(_localctx)->consequent_ = statement();
      setState(448);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx)) {
      case 1: {
        setState(446);
        match(FormalParser::Else);
        setState(447);
        dynamic_cast<IfStatementContext *>(_localctx)->alternate = statement();
        break;
      }

      }

              dynamic_cast<IfStatementContext *>(_localctx)->type =  "IfStatement";
          
      break;
    }

    case 7: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::DoWhileStatementContext>(_localctx));
      enterOuterAlt(_localctx, 7);
      setState(452);
      match(FormalParser::Do);
      setState(453);
      dynamic_cast<DoWhileStatementContext *>(_localctx)->body_ = statement();
      setState(454);
      match(FormalParser::While);
      setState(455);
      match(FormalParser::OpenParen);
      setState(456);
      dynamic_cast<DoWhileStatementContext *>(_localctx)->test_ = expressionSequence();
      setState(457);
      match(FormalParser::CloseParen);
      setState(458);
      eos();

              dynamic_cast<DoWhileStatementContext *>(_localctx)->type =  "DoWhileStatement";
          
      break;
    }

    case 8: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::WhileStatementContext>(_localctx));
      enterOuterAlt(_localctx, 8);
      setState(461);
      match(FormalParser::While);
      setState(462);
      match(FormalParser::OpenParen);
      setState(463);
      dynamic_cast<WhileStatementContext *>(_localctx)->test_ = expressionSequence();
      setState(464);
      match(FormalParser::CloseParen);
      setState(465);
      dynamic_cast<WhileStatementContext *>(_localctx)->body_ = statement();

              dynamic_cast<WhileStatementContext *>(_localctx)->type =  "WhileStatement";
          
      break;
    }

    case 9: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ForStatementContext>(_localctx));
      enterOuterAlt(_localctx, 9);
      setState(468);
      match(FormalParser::For);
      setState(469);
      match(FormalParser::OpenParen);
      setState(471);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
      case 1: {
        setState(470);
        dynamic_cast<ForStatementContext *>(_localctx)->init_ = forInitStatement();
        break;
      }

      }
      setState(473);
      match(FormalParser::SemiColon);
      setState(475);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx)) {
      case 1: {
        setState(474);
        dynamic_cast<ForStatementContext *>(_localctx)->test_ = expressionSequence();
        break;
      }

      }
      setState(477);
      match(FormalParser::SemiColon);
      setState(479);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx)) {
      case 1: {
        setState(478);
        dynamic_cast<ForStatementContext *>(_localctx)->update_ = expressionSequence();
        break;
      }

      }
      setState(481);
      match(FormalParser::CloseParen);
      setState(482);
      dynamic_cast<ForStatementContext *>(_localctx)->body_ = statement();

              dynamic_cast<ForStatementContext *>(_localctx)->type =  "ForStatement";
          
      break;
    }

    case 10: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ForInStatementContext>(_localctx));
      enterOuterAlt(_localctx, 10);
      setState(485);
      match(FormalParser::For);
      setState(486);
      match(FormalParser::OpenParen);
      setState(487);
      dynamic_cast<ForInStatementContext *>(_localctx)->left_ = baseForXStatement();
      setState(488);
      match(FormalParser::In);
      setState(489);
      dynamic_cast<ForInStatementContext *>(_localctx)->right_ = expressionSequence();
      setState(490);
      match(FormalParser::CloseParen);
      setState(491);
      dynamic_cast<ForInStatementContext *>(_localctx)->body_ = statement();

              dynamic_cast<ForInStatementContext *>(_localctx)->type =  "ForInStatement";
          
      break;
    }

    case 11: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ForOfStatementContext>(_localctx));
      enterOuterAlt(_localctx, 11);
      setState(494);
      match(FormalParser::For);
      setState(495);
      match(FormalParser::OpenParen);
      setState(496);
      dynamic_cast<ForOfStatementContext *>(_localctx)->left_ = baseForXStatement();
      setState(497);
      match(FormalParser::Of);
      setState(498);
      dynamic_cast<ForOfStatementContext *>(_localctx)->right_ = expressionSequence();
      setState(499);
      match(FormalParser::CloseParen);
      setState(500);
      dynamic_cast<ForOfStatementContext *>(_localctx)->body_ = statement();

              dynamic_cast<ForOfStatementContext *>(_localctx)->type =  "ForOfStatement";
          
      break;
    }

    case 12: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ContinueStatementContext>(_localctx));
      enterOuterAlt(_localctx, 12);
      setState(503);
      match(FormalParser::Continue);
      setState(506);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx)) {
      case 1: {
        setState(504);

        if (!(this->notLineTerminator())) throw FailedPredicateException(this, "this->notLineTerminator()");
        setState(505);
        dynamic_cast<ContinueStatementContext *>(_localctx)->label_ = identifier();
        break;
      }

      }
      setState(508);
      eos();

              dynamic_cast<ContinueStatementContext *>(_localctx)->type =  "ContinueStatement";
          
      break;
    }

    case 13: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::BreakStatementContext>(_localctx));
      enterOuterAlt(_localctx, 13);
      setState(511);
      match(FormalParser::Break);
      setState(514);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx)) {
      case 1: {
        setState(512);

        if (!(this->notLineTerminator())) throw FailedPredicateException(this, "this->notLineTerminator()");
        setState(513);
        dynamic_cast<BreakStatementContext *>(_localctx)->label_ = identifier();
        break;
      }

      }
      setState(516);
      eos();

              dynamic_cast<BreakStatementContext *>(_localctx)->type =  "BreakStatement";
          
      break;
    }

    case 14: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ReturnStatementContext>(_localctx));
      enterOuterAlt(_localctx, 14);
      setState(519);
      match(FormalParser::Return);

      setState(520);

      if (!(this->notLineTerminator())) throw FailedPredicateException(this, "this->notLineTerminator()");
      setState(521);
      dynamic_cast<ReturnStatementContext *>(_localctx)->argument_ = expression(0);
      setState(523);
      eos();

      		dynamic_cast<ReturnStatementContext *>(_localctx)->type =  "ReturnStatement";
              this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<RETURN_OUTSIDE_FUNCTION>() ,SourceCodeLocation{_localctx->getStart()->getLine(), _localctx->getStart()->getCharPositionInLine()},  [&](){
                  return !this->isInFunction();
              } ); 

          
      break;
    }

    case 15: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ReturnStatementContext>(_localctx));
      enterOuterAlt(_localctx, 15);
      setState(526);
      match(FormalParser::Return);
      setState(527);
      eos();

              dynamic_cast<ReturnStatementContext *>(_localctx)->type =  "ReturnStatement";
          
      break;
    }

    case 16: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::WithStatementContext>(_localctx));
      enterOuterAlt(_localctx, 16);
      setState(530);
      match(FormalParser::With);
      setState(531);
      match(FormalParser::OpenParen);
      setState(532);
      dynamic_cast<WithStatementContext *>(_localctx)->object_ = expressionSequence();
      setState(533);
      match(FormalParser::CloseParen);
      setState(534);
      dynamic_cast<WithStatementContext *>(_localctx)->body_ = statement();

              dynamic_cast<WithStatementContext *>(_localctx)->type =  "WithStatement";
          
      break;
    }

    case 17: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::LabeledStatementContext>(_localctx));
      enterOuterAlt(_localctx, 17);
      setState(537);
      dynamic_cast<LabeledStatementContext *>(_localctx)->label_ = identifier();
      setState(538);
      match(FormalParser::Colon);
      setState(539);
      dynamic_cast<LabeledStatementContext *>(_localctx)->body_ = statement();

              dynamic_cast<LabeledStatementContext *>(_localctx)->type =  "LabeledStatement";
          
      break;
    }

    case 18: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::SwitchStatementContext>(_localctx));
      enterOuterAlt(_localctx, 18);
      setState(542);
      match(FormalParser::Switch);
      setState(543);
      match(FormalParser::OpenParen);
      setState(544);
      dynamic_cast<SwitchStatementContext *>(_localctx)->discriminant_ = expressionSequence();
      setState(545);
      match(FormalParser::CloseParen);
      setState(546);
      dynamic_cast<SwitchStatementContext *>(_localctx)->cases_ = switchCaseList();

              dynamic_cast<SwitchStatementContext *>(_localctx)->type =  "SwitchStatement";
          
      break;
    }

    case 19: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ThrowStatementContext>(_localctx));
      enterOuterAlt(_localctx, 19);
      setState(549);
      match(FormalParser::Throw);
      setState(550);

      if (!(this->notLineTerminator())) throw FailedPredicateException(this, "this->notLineTerminator()");
      setState(551);
      dynamic_cast<ThrowStatementContext *>(_localctx)->argument_ = expressionSequence();
      setState(552);
      eos();

              dynamic_cast<ThrowStatementContext *>(_localctx)->type =  "ThrowStatement";
          
      break;
    }

    case 20: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::TryStatementContext>(_localctx));
      enterOuterAlt(_localctx, 20);
      setState(555);
      match(FormalParser::Try);
      setState(556);
      dynamic_cast<TryStatementContext *>(_localctx)->block_ = braceBlock();
      setState(558);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx)) {
      case 1: {
        setState(557);
        dynamic_cast<TryStatementContext *>(_localctx)->handler_ = catchProduction();
        break;
      }

      }
      setState(561);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx)) {
      case 1: {
        setState(560);
        dynamic_cast<TryStatementContext *>(_localctx)->finalizer_ = finallyProduction();
        break;
      }

      }

              dynamic_cast<TryStatementContext *>(_localctx)->type =  "TryStatement";
          
      break;
    }

    case 21: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::DebuggerStatementContext>(_localctx));
      enterOuterAlt(_localctx, 21);
      setState(565);
      match(FormalParser::Debugger);
      setState(566);
      eos();

              dynamic_cast<DebuggerStatementContext *>(_localctx)->type =  "DebuggerStatement";
          
      break;
    }

    case 22: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::DeclarationStatementContext>(_localctx));
      enterOuterAlt(_localctx, 22);
      setState(569);
      declaration();
      break;
    }

    case 23: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::TSTypeAliasDeclarationContext>(_localctx));
      enterOuterAlt(_localctx, 23);
      setState(570);
      match(FormalParser::TypeAlias);
      setState(571);
      dynamic_cast<TSTypeAliasDeclarationContext *>(_localctx)->alias_ = identifier();
      setState(572);
      match(FormalParser::Assign);
      setState(573);
      dynamic_cast<TSTypeAliasDeclarationContext *>(_localctx)->original_ = type_(0);
      setState(574);
      eos();

              dynamic_cast<TSTypeAliasDeclarationContext *>(_localctx)->type =  "TSTypeAliasDeclaration";
          
      break;
    }

    case 24: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::TSEnumDeclarationContext>(_localctx));
      enterOuterAlt(_localctx, 24);
      setState(577);
      enumDeclaration();

              dynamic_cast<TSEnumDeclarationContext *>(_localctx)->type =  "TSEnumDeclaration";
          
      break;
    }

    case 25: {
      _localctx = dynamic_cast<StatementContext *>(_tracker.createInstance<FormalParser::ExpressionStatementContext>(_localctx));
      enterOuterAlt(_localctx, 25);
      setState(580);

      if (!(this->notOpenBraceAndNotFunction())) throw FailedPredicateException(this, "this->notOpenBraceAndNotFunction()");
      setState(581);
      dynamic_cast<ExpressionStatementContext *>(_localctx)->expression_ = expressionSequence();
      setState(583);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 37, _ctx)) {
      case 1: {
        setState(582);
        match(FormalParser::SemiColon);
        break;
      }

      }

              dynamic_cast<ExpressionStatementContext *>(_localctx)->type =  "ExpressionStatement";
          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BraceBlockContext ------------------------------------------------------------------

FormalParser::BraceBlockContext::BraceBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::BraceBlockContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::BraceBlockContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::StatementListContext* FormalParser::BraceBlockContext::statementList() {
  return getRuleContext<FormalParser::StatementListContext>(0);
}


size_t FormalParser::BraceBlockContext::getRuleIndex() const {
  return FormalParser::RuleBraceBlock;
}

size_t FormalParser::BraceBlockContext::getContextId() const {
  return FormalParser::ContextIdBraceBlock;
}


FormalParser::BraceBlockContext* FormalParser::braceBlock() {
  BraceBlockContext *_localctx = _tracker.createInstance<BraceBlockContext>(_ctx, getState());
  enterRule(_localctx, 48, FormalParser::RuleBraceBlock);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(589);
    match(FormalParser::OpenBrace);
    setState(591);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
    case 1: {
      setState(590);
      dynamic_cast<BraceBlockContext *>(_localctx)->body_ = statementList();
      break;
    }

    }
    setState(593);
    match(FormalParser::CloseBrace);

            dynamic_cast<BraceBlockContext *>(_localctx)->type =  "BlockStatement";
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeclarationContext ------------------------------------------------------------------

FormalParser::DeclarationContext::DeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::FunctionDeclarationContext* FormalParser::DeclarationContext::functionDeclaration() {
  return getRuleContext<FormalParser::FunctionDeclarationContext>(0);
}

FormalParser::VariableDeclarationContext* FormalParser::DeclarationContext::variableDeclaration() {
  return getRuleContext<FormalParser::VariableDeclarationContext>(0);
}

FormalParser::EosContext* FormalParser::DeclarationContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}

FormalParser::BaseClassContext* FormalParser::DeclarationContext::baseClass() {
  return getRuleContext<FormalParser::BaseClassContext>(0);
}


size_t FormalParser::DeclarationContext::getRuleIndex() const {
  return FormalParser::RuleDeclaration;
}

size_t FormalParser::DeclarationContext::getContextId() const {
  return FormalParser::ContextIdDeclaration;
}


FormalParser::DeclarationContext* FormalParser::declaration() {
  DeclarationContext *_localctx = _tracker.createInstance<DeclarationContext>(_ctx, getState());
  enterRule(_localctx, 50, FormalParser::RuleDeclaration);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(601);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FormalParser::Function_:
      case FormalParser::Async: {
        enterOuterAlt(_localctx, 1);
        setState(596);
        functionDeclaration();
        break;
      }

      case FormalParser::Var:
      case FormalParser::Const:
      case FormalParser::Let: {
        enterOuterAlt(_localctx, 2);
        setState(597);
        variableDeclaration();
        setState(598);
        eos();
        break;
      }

      case FormalParser::Class:
      case FormalParser::Declare:
      case FormalParser::Abstract: {
        enterOuterAlt(_localctx, 3);
        setState(600);
        baseClass();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionDeclarationContext ------------------------------------------------------------------

FormalParser::FunctionDeclarationContext::FunctionDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::BaseFunctionContext* FormalParser::FunctionDeclarationContext::baseFunction() {
  return getRuleContext<FormalParser::BaseFunctionContext>(0);
}

tree::TerminalNode* FormalParser::FunctionDeclarationContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}

FormalParser::BraceBlockContext* FormalParser::FunctionDeclarationContext::braceBlock() {
  return getRuleContext<FormalParser::BraceBlockContext>(0);
}


size_t FormalParser::FunctionDeclarationContext::getRuleIndex() const {
  return FormalParser::RuleFunctionDeclaration;
}

size_t FormalParser::FunctionDeclarationContext::getContextId() const {
  return FormalParser::ContextIdFunctionDeclaration;
}


FormalParser::FunctionDeclarationContext* FormalParser::functionDeclaration() {
  FunctionDeclarationContext *_localctx = _tracker.createInstance<FunctionDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 52, FormalParser::RuleFunctionDeclaration);

      dynamic_cast<FunctionDeclarationContext *>(_localctx)->type =  "FunctionDeclaration";


  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(603);
    dynamic_cast<FunctionDeclarationContext *>(_localctx)->baseFunction_ = baseFunction();
    setState(606);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) {
    case 1: {
      setState(604);
      dynamic_cast<FunctionDeclarationContext *>(_localctx)->body_ = braceBlock();
      break;
    }

    case 2: {
      setState(605);
      match(FormalParser::SemiColon);
      break;
    }

    }
   _ctx->stop = _input->LT(-1);

        this->leaveFunction();

  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseFunctionContext ------------------------------------------------------------------

FormalParser::BaseFunctionContext::BaseFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::BaseFunctionContext::Function_() {
  return getToken(FormalParser::Function_, 0);
}

tree::TerminalNode* FormalParser::BaseFunctionContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::BaseFunctionContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

tree::TerminalNode* FormalParser::BaseFunctionContext::Async() {
  return getToken(FormalParser::Async, 0);
}

tree::TerminalNode* FormalParser::BaseFunctionContext::Multiply() {
  return getToken(FormalParser::Multiply, 0);
}

tree::TerminalNode* FormalParser::BaseFunctionContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

FormalParser::IdentifierContext* FormalParser::BaseFunctionContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::ParameterListContext* FormalParser::BaseFunctionContext::parameterList() {
  return getRuleContext<FormalParser::ParameterListContext>(0);
}

FormalParser::FunctionReturnTypeContext* FormalParser::BaseFunctionContext::functionReturnType() {
  return getRuleContext<FormalParser::FunctionReturnTypeContext>(0);
}


size_t FormalParser::BaseFunctionContext::getRuleIndex() const {
  return FormalParser::RuleBaseFunction;
}

size_t FormalParser::BaseFunctionContext::getContextId() const {
  return FormalParser::ContextIdBaseFunction;
}


FormalParser::BaseFunctionContext* FormalParser::baseFunction() {
  BaseFunctionContext *_localctx = _tracker.createInstance<BaseFunctionContext>(_ctx, getState());
  enterRule(_localctx, 54, FormalParser::RuleBaseFunction);

      this->enterFunction(); 

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(609);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Async) {
      setState(608);
      match(FormalParser::Async);
    }
    setState(611);
    match(FormalParser::Function_);
    setState(613);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx)) {
    case 1: {
      setState(612);
      match(FormalParser::Multiply);
      break;
    }

    }
    setState(616);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 44, _ctx)) {
    case 1: {
      setState(615);
      dynamic_cast<BaseFunctionContext *>(_localctx)->id_ = identifier();
      break;
    }

    }
    setState(618);
    match(FormalParser::OpenParen);
    setState(620);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 45, _ctx)) {
    case 1: {
      setState(619);
      dynamic_cast<BaseFunctionContext *>(_localctx)->params_ = parameterList();
      break;
    }

    }
    setState(622);
    match(FormalParser::CloseParen);
    setState(625);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx)) {
    case 1: {
      setState(623);
      match(FormalParser::Colon);
      setState(624);
      dynamic_cast<BaseFunctionContext *>(_localctx)->typeAnnotation_ = functionReturnType();
      break;
    }

    }

            dynamic_cast<BaseFunctionContext *>(_localctx)->async_ =  nullptr != _localctx->Async();
            dynamic_cast<BaseFunctionContext *>(_localctx)->generator_ =  nullptr != _localctx->Multiply();
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseClassContext ------------------------------------------------------------------

FormalParser::BaseClassContext::BaseClassContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::BaseClassContext::Class() {
  return getToken(FormalParser::Class, 0);
}

FormalParser::ClassBodyContext* FormalParser::BaseClassContext::classBody() {
  return getRuleContext<FormalParser::ClassBodyContext>(0);
}

tree::TerminalNode* FormalParser::BaseClassContext::Declare() {
  return getToken(FormalParser::Declare, 0);
}

tree::TerminalNode* FormalParser::BaseClassContext::Abstract() {
  return getToken(FormalParser::Abstract, 0);
}

FormalParser::IdentifierContext* FormalParser::BaseClassContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::ClassExtendsClauseContext* FormalParser::BaseClassContext::classExtendsClause() {
  return getRuleContext<FormalParser::ClassExtendsClauseContext>(0);
}

FormalParser::ImplementsClauseContext* FormalParser::BaseClassContext::implementsClause() {
  return getRuleContext<FormalParser::ImplementsClauseContext>(0);
}


size_t FormalParser::BaseClassContext::getRuleIndex() const {
  return FormalParser::RuleBaseClass;
}

size_t FormalParser::BaseClassContext::getContextId() const {
  return FormalParser::ContextIdBaseClass;
}


FormalParser::BaseClassContext* FormalParser::baseClass() {
  BaseClassContext *_localctx = _tracker.createInstance<BaseClassContext>(_ctx, getState());
  enterRule(_localctx, 56, FormalParser::RuleBaseClass);

      this->enterClassDeclaration();  

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(630);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Declare) {
      setState(629);
      match(FormalParser::Declare);
    }
    setState(633);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Abstract) {
      setState(632);
      match(FormalParser::Abstract);
    }
    setState(635);
    match(FormalParser::Class);
    setState(637);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
    case 1: {
      setState(636);
      dynamic_cast<BaseClassContext *>(_localctx)->id_ = identifier();
      break;
    }

    }
    setState(640);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Extends) {
      setState(639);
      dynamic_cast<BaseClassContext *>(_localctx)->superClass_ = classExtendsClause();
    }
    setState(643);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Implements) {
      setState(642);
      dynamic_cast<BaseClassContext *>(_localctx)->implements_ = implementsClause();
    }
    setState(645);
    dynamic_cast<BaseClassContext *>(_localctx)->body_ = classBody();
     
    		dynamic_cast<BaseClassContext *>(_localctx)->type =  dynamic_cast<ExpressionContext*>(_localctx->parent) ?  "ClassExpression" : "ClassDeclaration";
        
   _ctx->stop = _input->LT(-1);

        this->leaveClassDeclaration();

  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementListContext ------------------------------------------------------------------

FormalParser::StatementListContext::StatementListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::StatementContext *> FormalParser::StatementListContext::statement() {
  return getRuleContexts<FormalParser::StatementContext>();
}

FormalParser::StatementContext* FormalParser::StatementListContext::statement(size_t i) {
  return getRuleContext<FormalParser::StatementContext>(i);
}


size_t FormalParser::StatementListContext::getRuleIndex() const {
  return FormalParser::RuleStatementList;
}

size_t FormalParser::StatementListContext::getContextId() const {
  return FormalParser::ContextIdStatementList;
}


FormalParser::StatementListContext* FormalParser::statementList() {
  StatementListContext *_localctx = _tracker.createInstance<StatementListContext>(_ctx, getState());
  enterRule(_localctx, 58, FormalParser::RuleStatementList);

  	    dynamic_cast<StatementListContext *>(_localctx)->isArrayList =  true;


  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(649); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(648);
              statement();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(651); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 52, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FromBlockContext ------------------------------------------------------------------

FormalParser::FromBlockContext::FromBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::FromBlockContext::From() {
  return getToken(FormalParser::From, 0);
}

tree::TerminalNode* FormalParser::FromBlockContext::StringLiteral() {
  return getToken(FormalParser::StringLiteral, 0);
}

FormalParser::EosContext* FormalParser::FromBlockContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}

tree::TerminalNode* FormalParser::FromBlockContext::Multiply() {
  return getToken(FormalParser::Multiply, 0);
}

FormalParser::MultipleImportStatementContext* FormalParser::FromBlockContext::multipleImportStatement() {
  return getRuleContext<FormalParser::MultipleImportStatementContext>(0);
}

tree::TerminalNode* FormalParser::FromBlockContext::As() {
  return getToken(FormalParser::As, 0);
}

FormalParser::IdentifierContext* FormalParser::FromBlockContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}


size_t FormalParser::FromBlockContext::getRuleIndex() const {
  return FormalParser::RuleFromBlock;
}

size_t FormalParser::FromBlockContext::getContextId() const {
  return FormalParser::ContextIdFromBlock;
}


FormalParser::FromBlockContext* FormalParser::fromBlock() {
  FromBlockContext *_localctx = _tracker.createInstance<FromBlockContext>(_ctx, getState());
  enterRule(_localctx, 60, FormalParser::RuleFromBlock);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(655);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 53, _ctx)) {
    case 1: {
      setState(653);
      match(FormalParser::Multiply);
      break;
    }

    case 2: {
      setState(654);
      dynamic_cast<FromBlockContext *>(_localctx)->multipleImportStatement_ = multipleImportStatement();
      break;
    }

    }
    setState(659);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::As) {
      setState(657);
      match(FormalParser::As);
      setState(658);
      dynamic_cast<FromBlockContext *>(_localctx)->id_ = identifier();
    }
    setState(661);
    match(FormalParser::From);
    setState(662);
    match(FormalParser::StringLiteral);
    setState(663);
    eos();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MultipleImportStatementContext ------------------------------------------------------------------

FormalParser::MultipleImportStatementContext::MultipleImportStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::MultipleImportStatementContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

std::vector<FormalParser::IdentifierContext *> FormalParser::MultipleImportStatementContext::identifier() {
  return getRuleContexts<FormalParser::IdentifierContext>();
}

FormalParser::IdentifierContext* FormalParser::MultipleImportStatementContext::identifier(size_t i) {
  return getRuleContext<FormalParser::IdentifierContext>(i);
}

tree::TerminalNode* FormalParser::MultipleImportStatementContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

std::vector<tree::TerminalNode *> FormalParser::MultipleImportStatementContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::MultipleImportStatementContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::MultipleImportStatementContext::getRuleIndex() const {
  return FormalParser::RuleMultipleImportStatement;
}

size_t FormalParser::MultipleImportStatementContext::getContextId() const {
  return FormalParser::ContextIdMultipleImportStatement;
}


FormalParser::MultipleImportStatementContext* FormalParser::multipleImportStatement() {
  MultipleImportStatementContext *_localctx = _tracker.createInstance<MultipleImportStatementContext>(_ctx, getState());
  enterRule(_localctx, 62, FormalParser::RuleMultipleImportStatement);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(668);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 55, _ctx)) {
    case 1: {
      setState(665);
      identifier();
      setState(666);
      match(FormalParser::Comma);
      break;
    }

    }
    setState(670);
    match(FormalParser::OpenBrace);
    setState(671);
    identifier();
    setState(676);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::Comma) {
      setState(672);
      match(FormalParser::Comma);
      setState(673);
      identifier();
      setState(678);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(679);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VariableDeclarationContext ------------------------------------------------------------------

FormalParser::VariableDeclarationContext::VariableDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::VarModifierContext* FormalParser::VariableDeclarationContext::varModifier() {
  return getRuleContext<FormalParser::VarModifierContext>(0);
}

FormalParser::VariableDeclaratorListContext* FormalParser::VariableDeclarationContext::variableDeclaratorList() {
  return getRuleContext<FormalParser::VariableDeclaratorListContext>(0);
}

tree::TerminalNode* FormalParser::VariableDeclarationContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}

tree::TerminalNode* FormalParser::VariableDeclarationContext::Let() {
  return getToken(FormalParser::Let, 0);
}

FormalParser::EosContext* FormalParser::VariableDeclarationContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}


size_t FormalParser::VariableDeclarationContext::getRuleIndex() const {
  return FormalParser::RuleVariableDeclaration;
}

size_t FormalParser::VariableDeclarationContext::getContextId() const {
  return FormalParser::ContextIdVariableDeclaration;
}


FormalParser::VariableDeclarationContext* FormalParser::variableDeclaration() {
  VariableDeclarationContext *_localctx = _tracker.createInstance<VariableDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 64, FormalParser::RuleVariableDeclaration);

      this->enterVariableDeclaration();


  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(692);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(681);
      dynamic_cast<VariableDeclarationContext *>(_localctx)->kind_ = varModifier();
      setState(682);
      dynamic_cast<VariableDeclarationContext *>(_localctx)->declarations_ = variableDeclaratorList();
      setState(684);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 57, _ctx)) {
      case 1: {
        setState(683);
        match(FormalParser::SemiColon);
        break;
      }

      }

              dynamic_cast<VariableDeclarationContext *>(_localctx)->type =  "VariableDeclaration";
          
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(688);
      dynamic_cast<VariableDeclarationContext *>(_localctx)->letToken = match(FormalParser::Let);
      setState(689);
      eos();

      		this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<USE_KEYWORD_AS_IDENTIFIER>(dynamic_cast<VariableDeclarationContext *>(_localctx)->letToken), dynamic_cast<VariableDeclarationContext *>(_localctx)->letToken); 
          
      break;
    }

    }
   _ctx->stop = _input->LT(-1);

        this->leaveVariableDeclaration();

  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VariableDeclaratorListContext ------------------------------------------------------------------

FormalParser::VariableDeclaratorListContext::VariableDeclaratorListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::VariableDeclaratorContext *> FormalParser::VariableDeclaratorListContext::variableDeclarator() {
  return getRuleContexts<FormalParser::VariableDeclaratorContext>();
}

FormalParser::VariableDeclaratorContext* FormalParser::VariableDeclaratorListContext::variableDeclarator(size_t i) {
  return getRuleContext<FormalParser::VariableDeclaratorContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::VariableDeclaratorListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::VariableDeclaratorListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::VariableDeclaratorListContext::getRuleIndex() const {
  return FormalParser::RuleVariableDeclaratorList;
}

size_t FormalParser::VariableDeclaratorListContext::getContextId() const {
  return FormalParser::ContextIdVariableDeclaratorList;
}


FormalParser::VariableDeclaratorListContext* FormalParser::variableDeclaratorList() {
  VariableDeclaratorListContext *_localctx = _tracker.createInstance<VariableDeclaratorListContext>(_ctx, getState());
  enterRule(_localctx, 66, FormalParser::RuleVariableDeclaratorList);

  	    dynamic_cast<VariableDeclaratorListContext *>(_localctx)->isArrayList =  true;


  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(694);
    variableDeclarator();
    setState(699);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 59, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(695);
        match(FormalParser::Comma);
        setState(696);
        variableDeclarator(); 
      }
      setState(701);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 59, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VariableDeclaratorContext ------------------------------------------------------------------

FormalParser::VariableDeclaratorContext::VariableDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::PatternContext* FormalParser::VariableDeclaratorContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

tree::TerminalNode* FormalParser::VariableDeclaratorContext::Assign() {
  return getToken(FormalParser::Assign, 0);
}

FormalParser::ExpressionContext* FormalParser::VariableDeclaratorContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}

FormalParser::KeywordContext* FormalParser::VariableDeclaratorContext::keyword() {
  return getRuleContext<FormalParser::KeywordContext>(0);
}


size_t FormalParser::VariableDeclaratorContext::getRuleIndex() const {
  return FormalParser::RuleVariableDeclarator;
}

size_t FormalParser::VariableDeclaratorContext::getContextId() const {
  return FormalParser::ContextIdVariableDeclarator;
}


FormalParser::VariableDeclaratorContext* FormalParser::variableDeclarator() {
  VariableDeclaratorContext *_localctx = _tracker.createInstance<VariableDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 68, FormalParser::RuleVariableDeclarator);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(714);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(702);
      dynamic_cast<VariableDeclaratorContext *>(_localctx)->id_ = pattern();
      setState(705);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx)) {
      case 1: {
        setState(703);
        match(FormalParser::Assign);
        setState(704);
        dynamic_cast<VariableDeclaratorContext *>(_localctx)->init_ = expression(0);
        break;
      }

      }

              dynamic_cast<VariableDeclaratorContext *>(_localctx)->type =  "VariableDeclarator";
      	        this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<MUST_INIT_CONST_DECLARATION>(),([&](){
                  return nullptr == _localctx->init_ && this->variableDeclarationModifierIsConst();

              }  ));  
          
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(709);
      dynamic_cast<VariableDeclaratorContext *>(_localctx)->id_ = pattern();
      setState(710);
      match(FormalParser::Assign);
      setState(711);
      dynamic_cast<VariableDeclaratorContext *>(_localctx)->keywordContext = keyword();

              dynamic_cast<VariableDeclaratorContext *>(_localctx)->type =  "VariableDeclarator";
      		this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<USING_RESERVED_KEYWORD>((dynamic_cast<VariableDeclaratorContext *>(_localctx)->keywordContext != nullptr ? _input->getText(dynamic_cast<VariableDeclaratorContext *>(_localctx)->keywordContext->start, dynamic_cast<VariableDeclaratorContext *>(_localctx)->keywordContext->stop) : nullptr)),_localctx->getStart());
          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ForInitStatementContext ------------------------------------------------------------------

FormalParser::ForInitStatementContext::ForInitStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::VariableDeclarationContext* FormalParser::ForInitStatementContext::variableDeclaration() {
  return getRuleContext<FormalParser::VariableDeclarationContext>(0);
}

FormalParser::ExpressionContext* FormalParser::ForInitStatementContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::ForInitStatementContext::getRuleIndex() const {
  return FormalParser::RuleForInitStatement;
}

size_t FormalParser::ForInitStatementContext::getContextId() const {
  return FormalParser::ContextIdForInitStatement;
}


FormalParser::ForInitStatementContext* FormalParser::forInitStatement() {
  ForInitStatementContext *_localctx = _tracker.createInstance<ForInitStatementContext>(_ctx, getState());
  enterRule(_localctx, 70, FormalParser::RuleForInitStatement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(718);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 62, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(716);
      variableDeclaration();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(717);
      expression(0);
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseForXStatementContext ------------------------------------------------------------------

FormalParser::BaseForXStatementContext::BaseForXStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::VariableDeclarationContext* FormalParser::BaseForXStatementContext::variableDeclaration() {
  return getRuleContext<FormalParser::VariableDeclarationContext>(0);
}

FormalParser::PatternContext* FormalParser::BaseForXStatementContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

FormalParser::ExpressionContext* FormalParser::BaseForXStatementContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::BaseForXStatementContext::getRuleIndex() const {
  return FormalParser::RuleBaseForXStatement;
}

size_t FormalParser::BaseForXStatementContext::getContextId() const {
  return FormalParser::ContextIdBaseForXStatement;
}


FormalParser::BaseForXStatementContext* FormalParser::baseForXStatement() {
  BaseForXStatementContext *_localctx = _tracker.createInstance<BaseForXStatementContext>(_ctx, getState());
  enterRule(_localctx, 72, FormalParser::RuleBaseForXStatement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(725);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(720);
      variableDeclaration();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(721);
      pattern();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(722);
      expression(0);

      		if(_localctx->expression()->type != "MemberExpression"){
      			this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<RVALUE_IN_ASSIGNMENT_LEFT>() ,SourceCodeLocation{_localctx->getStart()->getLine(), _localctx->getStart()->getCharPositionInLine()});

      		}

      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VarModifierContext ------------------------------------------------------------------

FormalParser::VarModifierContext::VarModifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::VarModifierContext::Var() {
  return getToken(FormalParser::Var, 0);
}

tree::TerminalNode* FormalParser::VarModifierContext::Let() {
  return getToken(FormalParser::Let, 0);
}

tree::TerminalNode* FormalParser::VarModifierContext::Const() {
  return getToken(FormalParser::Const, 0);
}


size_t FormalParser::VarModifierContext::getRuleIndex() const {
  return FormalParser::RuleVarModifier;
}

size_t FormalParser::VarModifierContext::getContextId() const {
  return FormalParser::ContextIdVarModifier;
}


FormalParser::VarModifierContext* FormalParser::varModifier() {
  VarModifierContext *_localctx = _tracker.createInstance<VarModifierContext>(_ctx, getState());
  enterRule(_localctx, 74, FormalParser::RuleVarModifier);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(727);
    _la = _input->LA(1);
    if (!(((((_la - 75) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 75)) & ((1ULL << (FormalParser::Var - 75))
      | (1ULL << (FormalParser::Const - 75))
      | (1ULL << (FormalParser::Let - 75)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SwitchCaseListContext ------------------------------------------------------------------

FormalParser::SwitchCaseListContext::SwitchCaseListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::SwitchCaseListContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::SwitchCaseListContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

std::vector<FormalParser::CaseClausesContext *> FormalParser::SwitchCaseListContext::caseClauses() {
  return getRuleContexts<FormalParser::CaseClausesContext>();
}

FormalParser::CaseClausesContext* FormalParser::SwitchCaseListContext::caseClauses(size_t i) {
  return getRuleContext<FormalParser::CaseClausesContext>(i);
}

FormalParser::DefaultClauseContext* FormalParser::SwitchCaseListContext::defaultClause() {
  return getRuleContext<FormalParser::DefaultClauseContext>(0);
}


size_t FormalParser::SwitchCaseListContext::getRuleIndex() const {
  return FormalParser::RuleSwitchCaseList;
}

size_t FormalParser::SwitchCaseListContext::getContextId() const {
  return FormalParser::ContextIdSwitchCaseList;
}


FormalParser::SwitchCaseListContext* FormalParser::switchCaseList() {
  SwitchCaseListContext *_localctx = _tracker.createInstance<SwitchCaseListContext>(_ctx, getState());
  enterRule(_localctx, 76, FormalParser::RuleSwitchCaseList);

  	    dynamic_cast<SwitchCaseListContext *>(_localctx)->isArrayList =  true;

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(729);
    match(FormalParser::OpenBrace);
    setState(731);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Case) {
      setState(730);
      caseClauses();
    }
    setState(737);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Default) {
      setState(733);
      defaultClause();
      setState(735);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FormalParser::Case) {
        setState(734);
        caseClauses();
      }
    }
    setState(739);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CaseClausesContext ------------------------------------------------------------------

FormalParser::CaseClausesContext::CaseClausesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::CaseClauseContext *> FormalParser::CaseClausesContext::caseClause() {
  return getRuleContexts<FormalParser::CaseClauseContext>();
}

FormalParser::CaseClauseContext* FormalParser::CaseClausesContext::caseClause(size_t i) {
  return getRuleContext<FormalParser::CaseClauseContext>(i);
}


size_t FormalParser::CaseClausesContext::getRuleIndex() const {
  return FormalParser::RuleCaseClauses;
}

size_t FormalParser::CaseClausesContext::getContextId() const {
  return FormalParser::ContextIdCaseClauses;
}


FormalParser::CaseClausesContext* FormalParser::caseClauses() {
  CaseClausesContext *_localctx = _tracker.createInstance<CaseClausesContext>(_ctx, getState());
  enterRule(_localctx, 78, FormalParser::RuleCaseClauses);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(742); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(741);
      caseClause();
      setState(744); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FormalParser::Case);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CaseClauseContext ------------------------------------------------------------------

FormalParser::CaseClauseContext::CaseClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::CaseClauseContext::Case() {
  return getToken(FormalParser::Case, 0);
}

tree::TerminalNode* FormalParser::CaseClauseContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

FormalParser::ExpressionSequenceContext* FormalParser::CaseClauseContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

FormalParser::StatementListContext* FormalParser::CaseClauseContext::statementList() {
  return getRuleContext<FormalParser::StatementListContext>(0);
}


size_t FormalParser::CaseClauseContext::getRuleIndex() const {
  return FormalParser::RuleCaseClause;
}

size_t FormalParser::CaseClauseContext::getContextId() const {
  return FormalParser::ContextIdCaseClause;
}


FormalParser::CaseClauseContext* FormalParser::caseClause() {
  CaseClauseContext *_localctx = _tracker.createInstance<CaseClauseContext>(_ctx, getState());
  enterRule(_localctx, 80, FormalParser::RuleCaseClause);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(746);
    match(FormalParser::Case);
    setState(747);
    dynamic_cast<CaseClauseContext *>(_localctx)->test_ = expressionSequence();
    setState(748);
    match(FormalParser::Colon);
    setState(750);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx)) {
    case 1: {
      setState(749);
      dynamic_cast<CaseClauseContext *>(_localctx)->consequent_ = statementList();
      break;
    }

    }

            dynamic_cast<CaseClauseContext *>(_localctx)->type =  "SwitchCase";
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DefaultClauseContext ------------------------------------------------------------------

FormalParser::DefaultClauseContext::DefaultClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::DefaultClauseContext::Default() {
  return getToken(FormalParser::Default, 0);
}

tree::TerminalNode* FormalParser::DefaultClauseContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

FormalParser::StatementListContext* FormalParser::DefaultClauseContext::statementList() {
  return getRuleContext<FormalParser::StatementListContext>(0);
}


size_t FormalParser::DefaultClauseContext::getRuleIndex() const {
  return FormalParser::RuleDefaultClause;
}

size_t FormalParser::DefaultClauseContext::getContextId() const {
  return FormalParser::ContextIdDefaultClause;
}


FormalParser::DefaultClauseContext* FormalParser::defaultClause() {
  DefaultClauseContext *_localctx = _tracker.createInstance<DefaultClauseContext>(_ctx, getState());
  enterRule(_localctx, 82, FormalParser::RuleDefaultClause);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(754);
    match(FormalParser::Default);
    setState(755);
    match(FormalParser::Colon);
    setState(757);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx)) {
    case 1: {
      setState(756);
      dynamic_cast<DefaultClauseContext *>(_localctx)->consequent_ = statementList();
      break;
    }

    }

            dynamic_cast<DefaultClauseContext *>(_localctx)->type =  "SwitchCase";
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CatchProductionContext ------------------------------------------------------------------

FormalParser::CatchProductionContext::CatchProductionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::CatchProductionContext::Catch() {
  return getToken(FormalParser::Catch, 0);
}

tree::TerminalNode* FormalParser::CatchProductionContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::CatchProductionContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::IdentifierContext* FormalParser::CatchProductionContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::BraceBlockContext* FormalParser::CatchProductionContext::braceBlock() {
  return getRuleContext<FormalParser::BraceBlockContext>(0);
}


size_t FormalParser::CatchProductionContext::getRuleIndex() const {
  return FormalParser::RuleCatchProduction;
}

size_t FormalParser::CatchProductionContext::getContextId() const {
  return FormalParser::ContextIdCatchProduction;
}


FormalParser::CatchProductionContext* FormalParser::catchProduction() {
  CatchProductionContext *_localctx = _tracker.createInstance<CatchProductionContext>(_ctx, getState());
  enterRule(_localctx, 84, FormalParser::RuleCatchProduction);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(761);
    match(FormalParser::Catch);
    setState(762);
    match(FormalParser::OpenParen);
    setState(763);
    dynamic_cast<CatchProductionContext *>(_localctx)->param_ = identifier();
    setState(764);
    match(FormalParser::CloseParen);
    setState(765);
    dynamic_cast<CatchProductionContext *>(_localctx)->body_ = braceBlock();

            dynamic_cast<CatchProductionContext *>(_localctx)->type =  "CatchClause";
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FinallyProductionContext ------------------------------------------------------------------

FormalParser::FinallyProductionContext::FinallyProductionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::FinallyProductionContext::Finally() {
  return getToken(FormalParser::Finally, 0);
}

FormalParser::BraceBlockContext* FormalParser::FinallyProductionContext::braceBlock() {
  return getRuleContext<FormalParser::BraceBlockContext>(0);
}


size_t FormalParser::FinallyProductionContext::getRuleIndex() const {
  return FormalParser::RuleFinallyProduction;
}

size_t FormalParser::FinallyProductionContext::getContextId() const {
  return FormalParser::ContextIdFinallyProduction;
}


FormalParser::FinallyProductionContext* FormalParser::finallyProduction() {
  FinallyProductionContext *_localctx = _tracker.createInstance<FinallyProductionContext>(_ctx, getState());
  enterRule(_localctx, 86, FormalParser::RuleFinallyProduction);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(768);
    match(FormalParser::Finally);
    setState(769);
    braceBlock();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassBodyContext ------------------------------------------------------------------

FormalParser::ClassBodyContext::ClassBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ClassBodyContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::ClassBodyContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

std::vector<FormalParser::ClassElementContext *> FormalParser::ClassBodyContext::classElement() {
  return getRuleContexts<FormalParser::ClassElementContext>();
}

FormalParser::ClassElementContext* FormalParser::ClassBodyContext::classElement(size_t i) {
  return getRuleContext<FormalParser::ClassElementContext>(i);
}


size_t FormalParser::ClassBodyContext::getRuleIndex() const {
  return FormalParser::RuleClassBody;
}

size_t FormalParser::ClassBodyContext::getContextId() const {
  return FormalParser::ContextIdClassBody;
}


FormalParser::ClassBodyContext* FormalParser::classBody() {
  ClassBodyContext *_localctx = _tracker.createInstance<ClassBodyContext>(_ctx, getState());
  enterRule(_localctx, 88, FormalParser::RuleClassBody);

  	    dynamic_cast<ClassBodyContext *>(_localctx)->isArrayList =  true;


  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(771);
    match(FormalParser::OpenBrace);
    setState(775);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 70, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(772);
        classElement(); 
      }
      setState(777);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 70, _ctx);
    }
    setState(778);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassExtendsClauseContext ------------------------------------------------------------------

FormalParser::ClassExtendsClauseContext::ClassExtendsClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ClassExtendsClauseContext::Extends() {
  return getToken(FormalParser::Extends, 0);
}

FormalParser::TypeNameContext* FormalParser::ClassExtendsClauseContext::typeName() {
  return getRuleContext<FormalParser::TypeNameContext>(0);
}


size_t FormalParser::ClassExtendsClauseContext::getRuleIndex() const {
  return FormalParser::RuleClassExtendsClause;
}

size_t FormalParser::ClassExtendsClauseContext::getContextId() const {
  return FormalParser::ContextIdClassExtendsClause;
}


FormalParser::ClassExtendsClauseContext* FormalParser::classExtendsClause() {
  ClassExtendsClauseContext *_localctx = _tracker.createInstance<ClassExtendsClauseContext>(_ctx, getState());
  enterRule(_localctx, 90, FormalParser::RuleClassExtendsClause);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(780);
    match(FormalParser::Extends);
    setState(781);
    dynamic_cast<ClassExtendsClauseContext *>(_localctx)->superClass_ = typeName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ImplementsClauseContext ------------------------------------------------------------------

FormalParser::ImplementsClauseContext::ImplementsClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ImplementsClauseContext::Implements() {
  return getToken(FormalParser::Implements, 0);
}

FormalParser::ClassOrInterfaceTypeListContext* FormalParser::ImplementsClauseContext::classOrInterfaceTypeList() {
  return getRuleContext<FormalParser::ClassOrInterfaceTypeListContext>(0);
}


size_t FormalParser::ImplementsClauseContext::getRuleIndex() const {
  return FormalParser::RuleImplementsClause;
}

size_t FormalParser::ImplementsClauseContext::getContextId() const {
  return FormalParser::ContextIdImplementsClause;
}


FormalParser::ImplementsClauseContext* FormalParser::implementsClause() {
  ImplementsClauseContext *_localctx = _tracker.createInstance<ImplementsClauseContext>(_ctx, getState());
  enterRule(_localctx, 92, FormalParser::RuleImplementsClause);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(783);
    match(FormalParser::Implements);
    setState(784);
    dynamic_cast<ImplementsClauseContext *>(_localctx)->interfaces_ = classOrInterfaceTypeList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassElementContext ------------------------------------------------------------------

FormalParser::ClassElementContext::ClassElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::MethodDefinitionContext* FormalParser::ClassElementContext::methodDefinition() {
  return getRuleContext<FormalParser::MethodDefinitionContext>(0);
}

FormalParser::PropertyDefinitionContext* FormalParser::ClassElementContext::propertyDefinition() {
  return getRuleContext<FormalParser::PropertyDefinitionContext>(0);
}


size_t FormalParser::ClassElementContext::getRuleIndex() const {
  return FormalParser::RuleClassElement;
}

size_t FormalParser::ClassElementContext::getContextId() const {
  return FormalParser::ContextIdClassElement;
}


FormalParser::ClassElementContext* FormalParser::classElement() {
  ClassElementContext *_localctx = _tracker.createInstance<ClassElementContext>(_ctx, getState());
  enterRule(_localctx, 94, FormalParser::RuleClassElement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(788);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 71, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(786);
      methodDefinition();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(787);
      propertyDefinition();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MethodDefinitionContext ------------------------------------------------------------------

FormalParser::MethodDefinitionContext::MethodDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::MethodDefinitionContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::MethodDefinitionContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::PropertyNameContext* FormalParser::MethodDefinitionContext::propertyName() {
  return getRuleContext<FormalParser::PropertyNameContext>(0);
}

tree::TerminalNode* FormalParser::MethodDefinitionContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}

tree::TerminalNode* FormalParser::MethodDefinitionContext::Static() {
  return getToken(FormalParser::Static, 0);
}

tree::TerminalNode* FormalParser::MethodDefinitionContext::Async() {
  return getToken(FormalParser::Async, 0);
}

FormalParser::BraceBlockContext* FormalParser::MethodDefinitionContext::braceBlock() {
  return getRuleContext<FormalParser::BraceBlockContext>(0);
}

FormalParser::AccessibilityModifierContext* FormalParser::MethodDefinitionContext::accessibilityModifier() {
  return getRuleContext<FormalParser::AccessibilityModifierContext>(0);
}

FormalParser::AdvancedParameterListContext* FormalParser::MethodDefinitionContext::advancedParameterList() {
  return getRuleContext<FormalParser::AdvancedParameterListContext>(0);
}

FormalParser::GetAccessorContext* FormalParser::MethodDefinitionContext::getAccessor() {
  return getRuleContext<FormalParser::GetAccessorContext>(0);
}

FormalParser::SetAccessorContext* FormalParser::MethodDefinitionContext::setAccessor() {
  return getRuleContext<FormalParser::SetAccessorContext>(0);
}

tree::TerminalNode* FormalParser::MethodDefinitionContext::Constructor() {
  return getToken(FormalParser::Constructor, 0);
}


size_t FormalParser::MethodDefinitionContext::getRuleIndex() const {
  return FormalParser::RuleMethodDefinition;
}

size_t FormalParser::MethodDefinitionContext::getContextId() const {
  return FormalParser::ContextIdMethodDefinition;
}


FormalParser::MethodDefinitionContext* FormalParser::methodDefinition() {
  MethodDefinitionContext *_localctx = _tracker.createInstance<MethodDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 96, FormalParser::RuleMethodDefinition);

      dynamic_cast<MethodDefinitionContext *>(_localctx)->type =  "MethodDefinition";
   
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(838);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 83, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(791);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 72, _ctx)) {
      case 1: {
        setState(790);
        dynamic_cast<MethodDefinitionContext *>(_localctx)->accessibility_ = accessibilityModifier();
        break;
      }

      }
      setState(794);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 73, _ctx)) {
      case 1: {
        setState(793);
        match(FormalParser::Static);
        break;
      }

      }
      setState(797);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 74, _ctx)) {
      case 1: {
        setState(796);
        match(FormalParser::Async);
        break;
      }

      }
      setState(799);
      dynamic_cast<MethodDefinitionContext *>(_localctx)->key_ = propertyName();
      setState(800);
      match(FormalParser::OpenParen);
      setState(802);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx)) {
      case 1: {
        setState(801);
        dynamic_cast<MethodDefinitionContext *>(_localctx)->parameterList_ = advancedParameterList();
        break;
      }

      }
      setState(804);
      match(FormalParser::CloseParen);
      setState(807);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FormalParser::OpenBrace: {
          setState(805);
          dynamic_cast<MethodDefinitionContext *>(_localctx)->body_ = braceBlock();
          break;
        }

        case FormalParser::SemiColon: {
          setState(806);
          match(FormalParser::SemiColon);
          break;
        }

      default:
        throw NoViableAltException(this);
      }

              // dynamic_cast<MethodDefinitionContext *>(_localctx)->computed =  _localctx->key_ ? _localctx->key_->computed : false;
              // dynamic_cast<MethodDefinitionContext *>(_localctx)->kind =  "method";
              // dynamic_cast<MethodDefinitionContext *>(_localctx)->static_ =  nullptr != _localctx->Static();
              // dynamic_cast<MethodDefinitionContext *>(_localctx)->async_ =  nullptr != _localctx->Async();
          
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(812);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 108) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 108)) & ((1ULL << (FormalParser::Private - 108))
        | (1ULL << (FormalParser::Public - 108))
        | (1ULL << (FormalParser::Protected - 108)))) != 0)) {
        setState(811);
        dynamic_cast<MethodDefinitionContext *>(_localctx)->accessibility_ = accessibilityModifier();
      }
      setState(815);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FormalParser::Static) {
        setState(814);
        match(FormalParser::Static);
      }
      setState(818);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FormalParser::Async) {
        setState(817);
        match(FormalParser::Async);
      }
      setState(822);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FormalParser::Get: {
          setState(820);
          dynamic_cast<MethodDefinitionContext *>(_localctx)->getter_ = getAccessor();
          break;
        }

        case FormalParser::Set: {
          setState(821);
          dynamic_cast<MethodDefinitionContext *>(_localctx)->setter_ = setAccessor();
          break;
        }

      default:
        throw NoViableAltException(this);
      }

              // dynamic_cast<MethodDefinitionContext *>(_localctx)->computed =  false;
              // dynamic_cast<MethodDefinitionContext *>(_localctx)->kind =  nullptr == _localctx->getter_ ? "set" : "get";
              // dynamic_cast<MethodDefinitionContext *>(_localctx)->static_ =  nullptr != _localctx->Static();
              // dynamic_cast<MethodDefinitionContext *>(_localctx)->async_ =  nullptr != _localctx->Async();
          
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(827);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 108) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 108)) & ((1ULL << (FormalParser::Private - 108))
        | (1ULL << (FormalParser::Public - 108))
        | (1ULL << (FormalParser::Protected - 108)))) != 0)) {
        setState(826);
        dynamic_cast<MethodDefinitionContext *>(_localctx)->accessibility_ = accessibilityModifier();
      }
      setState(829);
      match(FormalParser::Constructor);
      setState(830);
      match(FormalParser::OpenParen);
      setState(832);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx)) {
      case 1: {
        setState(831);
        dynamic_cast<MethodDefinitionContext *>(_localctx)->parameterList_ = advancedParameterList();
        break;
      }

      }
      setState(834);
      match(FormalParser::CloseParen);
      setState(835);
      dynamic_cast<MethodDefinitionContext *>(_localctx)->body_ = braceBlock();

              dynamic_cast<MethodDefinitionContext *>(_localctx)->computed =  false;
              dynamic_cast<MethodDefinitionContext *>(_localctx)->kind =  "constructor";
              dynamic_cast<MethodDefinitionContext *>(_localctx)->static_ =  false;
              dynamic_cast<MethodDefinitionContext *>(_localctx)->async_ =  false;
          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PropertyDefinitionContext ------------------------------------------------------------------

FormalParser::PropertyDefinitionContext::PropertyDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::PropertyDefinitionContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}

FormalParser::PropertyNameContext* FormalParser::PropertyDefinitionContext::propertyName() {
  return getRuleContext<FormalParser::PropertyNameContext>(0);
}

tree::TerminalNode* FormalParser::PropertyDefinitionContext::Static() {
  return getToken(FormalParser::Static, 0);
}

tree::TerminalNode* FormalParser::PropertyDefinitionContext::ReadOnly() {
  return getToken(FormalParser::ReadOnly, 0);
}

tree::TerminalNode* FormalParser::PropertyDefinitionContext::QuestionMark() {
  return getToken(FormalParser::QuestionMark, 0);
}

FormalParser::AccessibilityModifierContext* FormalParser::PropertyDefinitionContext::accessibilityModifier() {
  return getRuleContext<FormalParser::AccessibilityModifierContext>(0);
}

FormalParser::TypeAnnotationContext* FormalParser::PropertyDefinitionContext::typeAnnotation() {
  return getRuleContext<FormalParser::TypeAnnotationContext>(0);
}

FormalParser::ExpressionContext* FormalParser::PropertyDefinitionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::PropertyDefinitionContext::getRuleIndex() const {
  return FormalParser::RulePropertyDefinition;
}

size_t FormalParser::PropertyDefinitionContext::getContextId() const {
  return FormalParser::ContextIdPropertyDefinition;
}


FormalParser::PropertyDefinitionContext* FormalParser::propertyDefinition() {
  PropertyDefinitionContext *_localctx = _tracker.createInstance<PropertyDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 98, FormalParser::RulePropertyDefinition);

      dynamic_cast<PropertyDefinitionContext *>(_localctx)->type =  "PropertyDefinition";
   

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(841);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _ctx)) {
    case 1: {
      setState(840);
      dynamic_cast<PropertyDefinitionContext *>(_localctx)->accessibility_ = accessibilityModifier();
      break;
    }

    }
    setState(844);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) {
    case 1: {
      setState(843);
      match(FormalParser::Static);
      break;
    }

    }
    setState(847);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
    case 1: {
      setState(846);
      match(FormalParser::ReadOnly);
      break;
    }

    }
    setState(849);
    dynamic_cast<PropertyDefinitionContext *>(_localctx)->key_ = propertyName();
    setState(851);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx)) {
    case 1: {
      setState(850);
      match(FormalParser::QuestionMark);
      break;
    }

    }
    setState(854);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 88, _ctx)) {
    case 1: {
      setState(853);
      dynamic_cast<PropertyDefinitionContext *>(_localctx)->typeAnnotation_ = typeAnnotation();
      break;
    }

    }
    setState(857);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 89, _ctx)) {
    case 1: {
      setState(856);
      dynamic_cast<PropertyDefinitionContext *>(_localctx)->value_ = expression(0);
      break;
    }

    }
    setState(859);
    match(FormalParser::SemiColon);

            // dynamic_cast<PropertyDefinitionContext *>(_localctx)->computed =  _localctx->key_ ? _localctx->key_->computed : false;
            // dynamic_cast<PropertyDefinitionContext *>(_localctx)->static_ =  nullptr != _localctx->Static();
            // dynamic_cast<PropertyDefinitionContext *>(_localctx)->readonly_ =  nullptr != _localctx->ReadOnly();
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GeneratorMethodContext ------------------------------------------------------------------

FormalParser::GeneratorMethodContext::GeneratorMethodContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::IdentifierContext* FormalParser::GeneratorMethodContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

tree::TerminalNode* FormalParser::GeneratorMethodContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::GeneratorMethodContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

tree::TerminalNode* FormalParser::GeneratorMethodContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

FormalParser::FunctionBodyContext* FormalParser::GeneratorMethodContext::functionBody() {
  return getRuleContext<FormalParser::FunctionBodyContext>(0);
}

tree::TerminalNode* FormalParser::GeneratorMethodContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

tree::TerminalNode* FormalParser::GeneratorMethodContext::Multiply() {
  return getToken(FormalParser::Multiply, 0);
}

FormalParser::ParameterListContext* FormalParser::GeneratorMethodContext::parameterList() {
  return getRuleContext<FormalParser::ParameterListContext>(0);
}


size_t FormalParser::GeneratorMethodContext::getRuleIndex() const {
  return FormalParser::RuleGeneratorMethod;
}

size_t FormalParser::GeneratorMethodContext::getContextId() const {
  return FormalParser::ContextIdGeneratorMethod;
}


FormalParser::GeneratorMethodContext* FormalParser::generatorMethod() {
  GeneratorMethodContext *_localctx = _tracker.createInstance<GeneratorMethodContext>(_ctx, getState());
  enterRule(_localctx, 100, FormalParser::RuleGeneratorMethod);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(863);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
    case 1: {
      setState(862);
      match(FormalParser::Multiply);
      break;
    }

    }
    setState(865);
    identifier();
    setState(866);
    match(FormalParser::OpenParen);
    setState(868);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx)) {
    case 1: {
      setState(867);
      parameterList();
      break;
    }

    }
    setState(870);
    match(FormalParser::CloseParen);
    setState(871);
    match(FormalParser::OpenBrace);
    setState(872);
    functionBody();
    setState(873);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GeneratorFunctionDeclarationContext ------------------------------------------------------------------

FormalParser::GeneratorFunctionDeclarationContext::GeneratorFunctionDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::GeneratorFunctionDeclarationContext::Function_() {
  return getToken(FormalParser::Function_, 0);
}

tree::TerminalNode* FormalParser::GeneratorFunctionDeclarationContext::Multiply() {
  return getToken(FormalParser::Multiply, 0);
}

tree::TerminalNode* FormalParser::GeneratorFunctionDeclarationContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::GeneratorFunctionDeclarationContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

tree::TerminalNode* FormalParser::GeneratorFunctionDeclarationContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

FormalParser::FunctionBodyContext* FormalParser::GeneratorFunctionDeclarationContext::functionBody() {
  return getRuleContext<FormalParser::FunctionBodyContext>(0);
}

tree::TerminalNode* FormalParser::GeneratorFunctionDeclarationContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::IdentifierContext* FormalParser::GeneratorFunctionDeclarationContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::ParameterListContext* FormalParser::GeneratorFunctionDeclarationContext::parameterList() {
  return getRuleContext<FormalParser::ParameterListContext>(0);
}


size_t FormalParser::GeneratorFunctionDeclarationContext::getRuleIndex() const {
  return FormalParser::RuleGeneratorFunctionDeclaration;
}

size_t FormalParser::GeneratorFunctionDeclarationContext::getContextId() const {
  return FormalParser::ContextIdGeneratorFunctionDeclaration;
}


FormalParser::GeneratorFunctionDeclarationContext* FormalParser::generatorFunctionDeclaration() {
  GeneratorFunctionDeclarationContext *_localctx = _tracker.createInstance<GeneratorFunctionDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 102, FormalParser::RuleGeneratorFunctionDeclaration);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(875);
    match(FormalParser::Function_);
    setState(876);
    match(FormalParser::Multiply);
    setState(878);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx)) {
    case 1: {
      setState(877);
      identifier();
      break;
    }

    }
    setState(880);
    match(FormalParser::OpenParen);
    setState(882);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 93, _ctx)) {
    case 1: {
      setState(881);
      parameterList();
      break;
    }

    }
    setState(884);
    match(FormalParser::CloseParen);
    setState(885);
    match(FormalParser::OpenBrace);
    setState(886);
    functionBody();
    setState(887);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GeneratorBlockContext ------------------------------------------------------------------

FormalParser::GeneratorBlockContext::GeneratorBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::GeneratorBlockContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

std::vector<FormalParser::GeneratorDefinitionContext *> FormalParser::GeneratorBlockContext::generatorDefinition() {
  return getRuleContexts<FormalParser::GeneratorDefinitionContext>();
}

FormalParser::GeneratorDefinitionContext* FormalParser::GeneratorBlockContext::generatorDefinition(size_t i) {
  return getRuleContext<FormalParser::GeneratorDefinitionContext>(i);
}

tree::TerminalNode* FormalParser::GeneratorBlockContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

std::vector<tree::TerminalNode *> FormalParser::GeneratorBlockContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::GeneratorBlockContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::GeneratorBlockContext::getRuleIndex() const {
  return FormalParser::RuleGeneratorBlock;
}

size_t FormalParser::GeneratorBlockContext::getContextId() const {
  return FormalParser::ContextIdGeneratorBlock;
}


FormalParser::GeneratorBlockContext* FormalParser::generatorBlock() {
  GeneratorBlockContext *_localctx = _tracker.createInstance<GeneratorBlockContext>(_ctx, getState());
  enterRule(_localctx, 104, FormalParser::RuleGeneratorBlock);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(889);
    match(FormalParser::OpenBrace);
    setState(890);
    generatorDefinition();
    setState(895);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(891);
        match(FormalParser::Comma);
        setState(892);
        generatorDefinition(); 
      }
      setState(897);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx);
    }
    setState(899);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Comma) {
      setState(898);
      match(FormalParser::Comma);
    }
    setState(901);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GeneratorDefinitionContext ------------------------------------------------------------------

FormalParser::GeneratorDefinitionContext::GeneratorDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::GeneratorDefinitionContext::Multiply() {
  return getToken(FormalParser::Multiply, 0);
}

FormalParser::IteratorDefinitionContext* FormalParser::GeneratorDefinitionContext::iteratorDefinition() {
  return getRuleContext<FormalParser::IteratorDefinitionContext>(0);
}


size_t FormalParser::GeneratorDefinitionContext::getRuleIndex() const {
  return FormalParser::RuleGeneratorDefinition;
}

size_t FormalParser::GeneratorDefinitionContext::getContextId() const {
  return FormalParser::ContextIdGeneratorDefinition;
}


FormalParser::GeneratorDefinitionContext* FormalParser::generatorDefinition() {
  GeneratorDefinitionContext *_localctx = _tracker.createInstance<GeneratorDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 106, FormalParser::RuleGeneratorDefinition);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(903);
    match(FormalParser::Multiply);
    setState(904);
    iteratorDefinition();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IteratorBlockContext ------------------------------------------------------------------

FormalParser::IteratorBlockContext::IteratorBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::IteratorBlockContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

std::vector<FormalParser::IteratorDefinitionContext *> FormalParser::IteratorBlockContext::iteratorDefinition() {
  return getRuleContexts<FormalParser::IteratorDefinitionContext>();
}

FormalParser::IteratorDefinitionContext* FormalParser::IteratorBlockContext::iteratorDefinition(size_t i) {
  return getRuleContext<FormalParser::IteratorDefinitionContext>(i);
}

tree::TerminalNode* FormalParser::IteratorBlockContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

std::vector<tree::TerminalNode *> FormalParser::IteratorBlockContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::IteratorBlockContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::IteratorBlockContext::getRuleIndex() const {
  return FormalParser::RuleIteratorBlock;
}

size_t FormalParser::IteratorBlockContext::getContextId() const {
  return FormalParser::ContextIdIteratorBlock;
}


FormalParser::IteratorBlockContext* FormalParser::iteratorBlock() {
  IteratorBlockContext *_localctx = _tracker.createInstance<IteratorBlockContext>(_ctx, getState());
  enterRule(_localctx, 108, FormalParser::RuleIteratorBlock);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(906);
    match(FormalParser::OpenBrace);
    setState(907);
    iteratorDefinition();
    setState(912);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(908);
        match(FormalParser::Comma);
        setState(909);
        iteratorDefinition(); 
      }
      setState(914);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx);
    }
    setState(916);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Comma) {
      setState(915);
      match(FormalParser::Comma);
    }
    setState(918);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IteratorDefinitionContext ------------------------------------------------------------------

FormalParser::IteratorDefinitionContext::IteratorDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::IteratorDefinitionContext::OpenBracket() {
  return getToken(FormalParser::OpenBracket, 0);
}

FormalParser::ExpressionContext* FormalParser::IteratorDefinitionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}

tree::TerminalNode* FormalParser::IteratorDefinitionContext::CloseBracket() {
  return getToken(FormalParser::CloseBracket, 0);
}

tree::TerminalNode* FormalParser::IteratorDefinitionContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::IteratorDefinitionContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

tree::TerminalNode* FormalParser::IteratorDefinitionContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

FormalParser::FunctionBodyContext* FormalParser::IteratorDefinitionContext::functionBody() {
  return getRuleContext<FormalParser::FunctionBodyContext>(0);
}

tree::TerminalNode* FormalParser::IteratorDefinitionContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::ParameterListContext* FormalParser::IteratorDefinitionContext::parameterList() {
  return getRuleContext<FormalParser::ParameterListContext>(0);
}


size_t FormalParser::IteratorDefinitionContext::getRuleIndex() const {
  return FormalParser::RuleIteratorDefinition;
}

size_t FormalParser::IteratorDefinitionContext::getContextId() const {
  return FormalParser::ContextIdIteratorDefinition;
}


FormalParser::IteratorDefinitionContext* FormalParser::iteratorDefinition() {
  IteratorDefinitionContext *_localctx = _tracker.createInstance<IteratorDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 110, FormalParser::RuleIteratorDefinition);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(920);
    match(FormalParser::OpenBracket);
    setState(921);
    expression(0);
    setState(922);
    match(FormalParser::CloseBracket);
    setState(923);
    match(FormalParser::OpenParen);
    setState(925);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98, _ctx)) {
    case 1: {
      setState(924);
      parameterList();
      break;
    }

    }
    setState(927);
    match(FormalParser::CloseParen);
    setState(928);
    match(FormalParser::OpenBrace);
    setState(929);
    functionBody();
    setState(930);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionBodyContext ------------------------------------------------------------------

FormalParser::FunctionBodyContext::FunctionBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::SourceArrayListContext* FormalParser::FunctionBodyContext::sourceArrayList() {
  return getRuleContext<FormalParser::SourceArrayListContext>(0);
}


size_t FormalParser::FunctionBodyContext::getRuleIndex() const {
  return FormalParser::RuleFunctionBody;
}

size_t FormalParser::FunctionBodyContext::getContextId() const {
  return FormalParser::ContextIdFunctionBody;
}


FormalParser::FunctionBodyContext* FormalParser::functionBody() {
  FunctionBodyContext *_localctx = _tracker.createInstance<FunctionBodyContext>(_ctx, getState());
  enterRule(_localctx, 112, FormalParser::RuleFunctionBody);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(933);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx)) {
    case 1: {
      setState(932);
      sourceArrayList();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceArrayListContext ------------------------------------------------------------------

FormalParser::SourceArrayListContext::SourceArrayListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::SourceElementContext *> FormalParser::SourceArrayListContext::sourceElement() {
  return getRuleContexts<FormalParser::SourceElementContext>();
}

FormalParser::SourceElementContext* FormalParser::SourceArrayListContext::sourceElement(size_t i) {
  return getRuleContext<FormalParser::SourceElementContext>(i);
}


size_t FormalParser::SourceArrayListContext::getRuleIndex() const {
  return FormalParser::RuleSourceArrayList;
}

size_t FormalParser::SourceArrayListContext::getContextId() const {
  return FormalParser::ContextIdSourceArrayList;
}


FormalParser::SourceArrayListContext* FormalParser::sourceArrayList() {
  SourceArrayListContext *_localctx = _tracker.createInstance<SourceArrayListContext>(_ctx, getState());
  enterRule(_localctx, 114, FormalParser::RuleSourceArrayList);

  	    dynamic_cast<SourceArrayListContext *>(_localctx)->isArrayList =  true;


  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(936); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(935);
              sourceElement();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(938); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 100, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SpreadElementContext ------------------------------------------------------------------

FormalParser::SpreadElementContext::SpreadElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::SpreadElementContext::Ellipsis() {
  return getToken(FormalParser::Ellipsis, 0);
}

FormalParser::ExpressionContext* FormalParser::SpreadElementContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::SpreadElementContext::getRuleIndex() const {
  return FormalParser::RuleSpreadElement;
}

size_t FormalParser::SpreadElementContext::getContextId() const {
  return FormalParser::ContextIdSpreadElement;
}


FormalParser::SpreadElementContext* FormalParser::spreadElement() {
  SpreadElementContext *_localctx = _tracker.createInstance<SpreadElementContext>(_ctx, getState());
  enterRule(_localctx, 116, FormalParser::RuleSpreadElement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(940);
    match(FormalParser::Ellipsis);
    setState(941);
    dynamic_cast<SpreadElementContext *>(_localctx)->argument_ = expression(0);

            dynamic_cast<SpreadElementContext *>(_localctx)->type =  "SpreadElement";
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArrayElementContext ------------------------------------------------------------------

FormalParser::ArrayElementContext::ArrayElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::SpreadElementContext* FormalParser::ArrayElementContext::spreadElement() {
  return getRuleContext<FormalParser::SpreadElementContext>(0);
}

FormalParser::ExpressionContext* FormalParser::ArrayElementContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::ArrayElementContext::getRuleIndex() const {
  return FormalParser::RuleArrayElement;
}

size_t FormalParser::ArrayElementContext::getContextId() const {
  return FormalParser::ContextIdArrayElement;
}


FormalParser::ArrayElementContext* FormalParser::arrayElement() {
  ArrayElementContext *_localctx = _tracker.createInstance<ArrayElementContext>(_ctx, getState());
  enterRule(_localctx, 118, FormalParser::RuleArrayElement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(946);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 101, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(944);
      spreadElement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(945);
      expression(0);
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArrayElementArrayListContext ------------------------------------------------------------------

FormalParser::ArrayElementArrayListContext::ArrayElementArrayListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::ArrayElementContext *> FormalParser::ArrayElementArrayListContext::arrayElement() {
  return getRuleContexts<FormalParser::ArrayElementContext>();
}

FormalParser::ArrayElementContext* FormalParser::ArrayElementArrayListContext::arrayElement(size_t i) {
  return getRuleContext<FormalParser::ArrayElementContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::ArrayElementArrayListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::ArrayElementArrayListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::ArrayElementArrayListContext::getRuleIndex() const {
  return FormalParser::RuleArrayElementArrayList;
}

size_t FormalParser::ArrayElementArrayListContext::getContextId() const {
  return FormalParser::ContextIdArrayElementArrayList;
}


FormalParser::ArrayElementArrayListContext* FormalParser::arrayElementArrayList() {
  ArrayElementArrayListContext *_localctx = _tracker.createInstance<ArrayElementArrayListContext>(_ctx, getState());
  enterRule(_localctx, 120, FormalParser::RuleArrayElementArrayList);

  	    dynamic_cast<ArrayElementArrayListContext *>(_localctx)->isArrayList =  true;

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(951);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 102, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(948);
        match(FormalParser::Comma); 
      }
      setState(953);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 102, _ctx);
    }
    setState(956);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 103, _ctx)) {
    case 1: {
      setState(954);
      arrayElement();
      break;
    }

    case 2: {
      setState(955);
      match(FormalParser::Comma);
      break;
    }

    }
    setState(966);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(959); 
        _errHandler->sync(this);
        alt = 1;
        do {
          switch (alt) {
            case 1: {
                  setState(958);
                  match(FormalParser::Comma);
                  break;
                }

          default:
            throw NoViableAltException(this);
          }
          setState(961); 
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx);
        } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
        setState(963);
        arrayElement(); 
      }
      setState(968);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx);
    }
    setState(972);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::Comma) {
      setState(969);
      match(FormalParser::Comma);
      setState(974);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArrayPatternElementArrayListContext ------------------------------------------------------------------

FormalParser::ArrayPatternElementArrayListContext::ArrayPatternElementArrayListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::PatternContext *> FormalParser::ArrayPatternElementArrayListContext::pattern() {
  return getRuleContexts<FormalParser::PatternContext>();
}

FormalParser::PatternContext* FormalParser::ArrayPatternElementArrayListContext::pattern(size_t i) {
  return getRuleContext<FormalParser::PatternContext>(i);
}

std::vector<FormalParser::AssignmentPatternContext *> FormalParser::ArrayPatternElementArrayListContext::assignmentPattern() {
  return getRuleContexts<FormalParser::AssignmentPatternContext>();
}

FormalParser::AssignmentPatternContext* FormalParser::ArrayPatternElementArrayListContext::assignmentPattern(size_t i) {
  return getRuleContext<FormalParser::AssignmentPatternContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::ArrayPatternElementArrayListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::ArrayPatternElementArrayListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::ArrayPatternElementArrayListContext::getRuleIndex() const {
  return FormalParser::RuleArrayPatternElementArrayList;
}

size_t FormalParser::ArrayPatternElementArrayListContext::getContextId() const {
  return FormalParser::ContextIdArrayPatternElementArrayList;
}


FormalParser::ArrayPatternElementArrayListContext* FormalParser::arrayPatternElementArrayList() {
  ArrayPatternElementArrayListContext *_localctx = _tracker.createInstance<ArrayPatternElementArrayListContext>(_ctx, getState());
  enterRule(_localctx, 122, FormalParser::RuleArrayPatternElementArrayList);

  	    dynamic_cast<ArrayPatternElementArrayListContext *>(_localctx)->isArrayList =  true;

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(978);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 107, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(975);
        match(FormalParser::Comma); 
      }
      setState(980);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 107, _ctx);
    }
    setState(984);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx)) {
    case 1: {
      setState(981);
      pattern();
      break;
    }

    case 2: {
      setState(982);
      assignmentPattern();
      break;
    }

    case 3: {
      setState(983);
      match(FormalParser::Comma);
      break;
    }

    }
    setState(997);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(987); 
        _errHandler->sync(this);
        alt = 1;
        do {
          switch (alt) {
            case 1: {
                  setState(986);
                  match(FormalParser::Comma);
                  break;
                }

          default:
            throw NoViableAltException(this);
          }
          setState(989); 
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx);
        } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
        setState(993);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx)) {
        case 1: {
          setState(991);
          pattern();
          break;
        }

        case 2: {
          setState(992);
          assignmentPattern();
          break;
        }

        } 
      }
      setState(999);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx);
    }
    setState(1003);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::Comma) {
      setState(1000);
      match(FormalParser::Comma);
      setState(1005);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ObjectElementContext ------------------------------------------------------------------

FormalParser::ObjectElementContext::ObjectElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::PropertyContext* FormalParser::ObjectElementContext::property() {
  return getRuleContext<FormalParser::PropertyContext>(0);
}

FormalParser::SpreadElementContext* FormalParser::ObjectElementContext::spreadElement() {
  return getRuleContext<FormalParser::SpreadElementContext>(0);
}


size_t FormalParser::ObjectElementContext::getRuleIndex() const {
  return FormalParser::RuleObjectElement;
}

size_t FormalParser::ObjectElementContext::getContextId() const {
  return FormalParser::ContextIdObjectElement;
}


FormalParser::ObjectElementContext* FormalParser::objectElement() {
  ObjectElementContext *_localctx = _tracker.createInstance<ObjectElementContext>(_ctx, getState());
  enterRule(_localctx, 124, FormalParser::RuleObjectElement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1008);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1006);
      property();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1007);
      spreadElement();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ObjectElementArrayListContext ------------------------------------------------------------------

FormalParser::ObjectElementArrayListContext::ObjectElementArrayListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::ObjectElementContext *> FormalParser::ObjectElementArrayListContext::objectElement() {
  return getRuleContexts<FormalParser::ObjectElementContext>();
}

FormalParser::ObjectElementContext* FormalParser::ObjectElementArrayListContext::objectElement(size_t i) {
  return getRuleContext<FormalParser::ObjectElementContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::ObjectElementArrayListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::ObjectElementArrayListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::ObjectElementArrayListContext::getRuleIndex() const {
  return FormalParser::RuleObjectElementArrayList;
}

size_t FormalParser::ObjectElementArrayListContext::getContextId() const {
  return FormalParser::ContextIdObjectElementArrayList;
}


FormalParser::ObjectElementArrayListContext* FormalParser::objectElementArrayList() {
  ObjectElementArrayListContext *_localctx = _tracker.createInstance<ObjectElementArrayListContext>(_ctx, getState());
  enterRule(_localctx, 126, FormalParser::RuleObjectElementArrayList);

  	    dynamic_cast<ObjectElementArrayListContext *>(_localctx)->isArrayList =  true;

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1010);
    objectElement();
    setState(1015);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1011);
        match(FormalParser::Comma);
        setState(1012);
        objectElement(); 
      }
      setState(1017);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx);
    }
    setState(1019);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Comma) {
      setState(1018);
      match(FormalParser::Comma);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PropertyNameContext ------------------------------------------------------------------

FormalParser::PropertyNameContext::PropertyNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::IdentifierContext* FormalParser::PropertyNameContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

tree::TerminalNode* FormalParser::PropertyNameContext::StringLiteral() {
  return getToken(FormalParser::StringLiteral, 0);
}

FormalParser::NumericLiteralContext* FormalParser::PropertyNameContext::numericLiteral() {
  return getRuleContext<FormalParser::NumericLiteralContext>(0);
}

FormalParser::PrivateIdentifierContext* FormalParser::PropertyNameContext::privateIdentifier() {
  return getRuleContext<FormalParser::PrivateIdentifierContext>(0);
}


size_t FormalParser::PropertyNameContext::getRuleIndex() const {
  return FormalParser::RulePropertyName;
}

size_t FormalParser::PropertyNameContext::getContextId() const {
  return FormalParser::ContextIdPropertyName;
}


FormalParser::PropertyNameContext* FormalParser::propertyName() {
  PropertyNameContext *_localctx = _tracker.createInstance<PropertyNameContext>(_ctx, getState());
  enterRule(_localctx, 128, FormalParser::RulePropertyName);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1032);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1021);
      identifier();

              dynamic_cast<PropertyNameContext *>(_localctx)->computed =  false;
          
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1024);
      match(FormalParser::StringLiteral);

              dynamic_cast<PropertyNameContext *>(_localctx)->computed =  true;
          
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1026);
      numericLiteral();

              dynamic_cast<PropertyNameContext *>(_localctx)->computed =  true;
          
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1029);
      privateIdentifier();

              dynamic_cast<PropertyNameContext *>(_localctx)->computed =  false;
          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PropertyKeyContext ------------------------------------------------------------------

FormalParser::PropertyKeyContext::PropertyKeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::ExpressionContext* FormalParser::PropertyKeyContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}

FormalParser::PrivateIdentifierContext* FormalParser::PropertyKeyContext::privateIdentifier() {
  return getRuleContext<FormalParser::PrivateIdentifierContext>(0);
}


size_t FormalParser::PropertyKeyContext::getRuleIndex() const {
  return FormalParser::RulePropertyKey;
}

size_t FormalParser::PropertyKeyContext::getContextId() const {
  return FormalParser::ContextIdPropertyKey;
}


FormalParser::PropertyKeyContext* FormalParser::propertyKey() {
  PropertyKeyContext *_localctx = _tracker.createInstance<PropertyKeyContext>(_ctx, getState());
  enterRule(_localctx, 130, FormalParser::RulePropertyKey);

  		this->enterPropertyKey();
  	

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1036);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 117, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1034);
      expression(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1035);
      privateIdentifier();
      break;
    }

    }
   _ctx->stop = _input->LT(-1);

    		this->leavePropertyKey();
    	
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PropertyContext ------------------------------------------------------------------

FormalParser::PropertyContext::PropertyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t FormalParser::PropertyContext::getRuleIndex() const {
  return FormalParser::RuleProperty;
}

size_t FormalParser::PropertyContext::getContextId() const {
  return FormalParser::ContextIdProperty;
}

void FormalParser::PropertyContext::copyFrom(PropertyContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
  this->type = ctx->type;
  this->method = ctx->method;
  this->shorthand = ctx->shorthand;
  this->computed = ctx->computed;
  this->kind = ctx->kind;
}

//----------------- PropertyExpressionAssignmentContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::PropertyExpressionAssignmentContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

FormalParser::PropertyKeyContext* FormalParser::PropertyExpressionAssignmentContext::propertyKey() {
  return getRuleContext<FormalParser::PropertyKeyContext>(0);
}

FormalParser::ExpressionContext* FormalParser::PropertyExpressionAssignmentContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::PropertyExpressionAssignmentContext::getContextId() const {
  return FormalParser::ContextIdPropertyExpressionAssignment;
}

FormalParser::PropertyExpressionAssignmentContext::PropertyExpressionAssignmentContext(PropertyContext *ctx) { copyFrom(ctx); }


//----------------- ComputedPropertyExpressionAssignmentContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ComputedPropertyExpressionAssignmentContext::OpenBracket() {
  return getToken(FormalParser::OpenBracket, 0);
}

tree::TerminalNode* FormalParser::ComputedPropertyExpressionAssignmentContext::CloseBracket() {
  return getToken(FormalParser::CloseBracket, 0);
}

tree::TerminalNode* FormalParser::ComputedPropertyExpressionAssignmentContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

std::vector<FormalParser::ExpressionContext *> FormalParser::ComputedPropertyExpressionAssignmentContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::ComputedPropertyExpressionAssignmentContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}


size_t FormalParser::ComputedPropertyExpressionAssignmentContext::getContextId() const {
  return FormalParser::ContextIdComputedPropertyExpressionAssignment;
}

FormalParser::ComputedPropertyExpressionAssignmentContext::ComputedPropertyExpressionAssignmentContext(PropertyContext *ctx) { copyFrom(ctx); }


//----------------- PropertyShorthandContext ------------------------------------------------------------------

FormalParser::PropertyKeyContext* FormalParser::PropertyShorthandContext::propertyKey() {
  return getRuleContext<FormalParser::PropertyKeyContext>(0);
}


size_t FormalParser::PropertyShorthandContext::getContextId() const {
  return FormalParser::ContextIdPropertyShorthand;
}

FormalParser::PropertyShorthandContext::PropertyShorthandContext(PropertyContext *ctx) { copyFrom(ctx); }


//----------------- PropertySetterContext ------------------------------------------------------------------

FormalParser::SetAccessorContext* FormalParser::PropertySetterContext::setAccessor() {
  return getRuleContext<FormalParser::SetAccessorContext>(0);
}


size_t FormalParser::PropertySetterContext::getContextId() const {
  return FormalParser::ContextIdPropertySetter;
}

FormalParser::PropertySetterContext::PropertySetterContext(PropertyContext *ctx) { copyFrom(ctx); }


//----------------- PropertyGetterContext ------------------------------------------------------------------

FormalParser::GetAccessorContext* FormalParser::PropertyGetterContext::getAccessor() {
  return getRuleContext<FormalParser::GetAccessorContext>(0);
}


size_t FormalParser::PropertyGetterContext::getContextId() const {
  return FormalParser::ContextIdPropertyGetter;
}

FormalParser::PropertyGetterContext::PropertyGetterContext(PropertyContext *ctx) { copyFrom(ctx); }


//----------------- MethodPropertyContext ------------------------------------------------------------------

FormalParser::GeneratorMethodContext* FormalParser::MethodPropertyContext::generatorMethod() {
  return getRuleContext<FormalParser::GeneratorMethodContext>(0);
}


size_t FormalParser::MethodPropertyContext::getContextId() const {
  return FormalParser::ContextIdMethodProperty;
}

FormalParser::MethodPropertyContext::MethodPropertyContext(PropertyContext *ctx) { copyFrom(ctx); }


FormalParser::PropertyContext* FormalParser::property() {
  PropertyContext *_localctx = _tracker.createInstance<PropertyContext>(_ctx, getState());
  enterRule(_localctx, 132, FormalParser::RuleProperty);

          dynamic_cast<PropertyContext *>(_localctx)->type =  "Property";


  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1062);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 118, _ctx)) {
    case 1: {
      _localctx = dynamic_cast<PropertyContext *>(_tracker.createInstance<FormalParser::PropertyExpressionAssignmentContext>(_localctx));
      enterOuterAlt(_localctx, 1);
      setState(1038);
      dynamic_cast<PropertyExpressionAssignmentContext *>(_localctx)->key_ = propertyKey();
      setState(1039);
      match(FormalParser::Colon);
      setState(1040);
      dynamic_cast<PropertyExpressionAssignmentContext *>(_localctx)->value_ = expression(0);

              dynamic_cast<PropertyExpressionAssignmentContext *>(_localctx)->method =  false;
              dynamic_cast<PropertyExpressionAssignmentContext *>(_localctx)->shorthand =  false;
              dynamic_cast<PropertyExpressionAssignmentContext *>(_localctx)->computed =  false;
              dynamic_cast<PropertyExpressionAssignmentContext *>(_localctx)->kind =  "init";
          
      break;
    }

    case 2: {
      _localctx = dynamic_cast<PropertyContext *>(_tracker.createInstance<FormalParser::ComputedPropertyExpressionAssignmentContext>(_localctx));
      enterOuterAlt(_localctx, 2);
      setState(1043);
      match(FormalParser::OpenBracket);
      setState(1044);
      dynamic_cast<ComputedPropertyExpressionAssignmentContext *>(_localctx)->key_ = expression(0);
      setState(1045);
      match(FormalParser::CloseBracket);
      setState(1046);
      match(FormalParser::Colon);
      setState(1047);
      dynamic_cast<ComputedPropertyExpressionAssignmentContext *>(_localctx)->value_ = expression(0);

              dynamic_cast<ComputedPropertyExpressionAssignmentContext *>(_localctx)->method =  false;
              dynamic_cast<ComputedPropertyExpressionAssignmentContext *>(_localctx)->shorthand =  false;
              dynamic_cast<ComputedPropertyExpressionAssignmentContext *>(_localctx)->computed =  true;
              dynamic_cast<ComputedPropertyExpressionAssignmentContext *>(_localctx)->kind =  "init";
          
      break;
    }

    case 3: {
      _localctx = dynamic_cast<PropertyContext *>(_tracker.createInstance<FormalParser::PropertyGetterContext>(_localctx));
      enterOuterAlt(_localctx, 3);
      setState(1050);
      getAccessor();

              dynamic_cast<PropertyGetterContext *>(_localctx)->method =  true;
              dynamic_cast<PropertyGetterContext *>(_localctx)->shorthand =  false;
              dynamic_cast<PropertyGetterContext *>(_localctx)->computed =  false;
              dynamic_cast<PropertyGetterContext *>(_localctx)->kind =  "get";

          
      break;
    }

    case 4: {
      _localctx = dynamic_cast<PropertyContext *>(_tracker.createInstance<FormalParser::PropertySetterContext>(_localctx));
      enterOuterAlt(_localctx, 4);
      setState(1053);
      setAccessor();

              dynamic_cast<PropertySetterContext *>(_localctx)->method =  true;
              dynamic_cast<PropertySetterContext *>(_localctx)->shorthand =  false;
              dynamic_cast<PropertySetterContext *>(_localctx)->computed =  false;
              dynamic_cast<PropertySetterContext *>(_localctx)->kind =  "set";

          
      break;
    }

    case 5: {
      _localctx = dynamic_cast<PropertyContext *>(_tracker.createInstance<FormalParser::MethodPropertyContext>(_localctx));
      enterOuterAlt(_localctx, 5);
      setState(1056);
      generatorMethod();

              dynamic_cast<MethodPropertyContext *>(_localctx)->method =  false;
              dynamic_cast<MethodPropertyContext *>(_localctx)->shorthand =  false;
              dynamic_cast<MethodPropertyContext *>(_localctx)->computed =  true;
              dynamic_cast<MethodPropertyContext *>(_localctx)->kind =  "init";

          
      break;
    }

    case 6: {
      _localctx = dynamic_cast<PropertyContext *>(_tracker.createInstance<FormalParser::PropertyShorthandContext>(_localctx));
      enterOuterAlt(_localctx, 6);
      setState(1059);
      dynamic_cast<PropertyShorthandContext *>(_localctx)->key_ = propertyKey();
         //NOTE For PropertyShorthand both key and value are all the same 
              dynamic_cast<PropertyShorthandContext *>(_localctx)->method =  false;
              dynamic_cast<PropertyShorthandContext *>(_localctx)->shorthand =  true;
              dynamic_cast<PropertyShorthandContext *>(_localctx)->computed =  false;
              dynamic_cast<PropertyShorthandContext *>(_localctx)->kind =  "init";

          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignmentPropertyContext ------------------------------------------------------------------

FormalParser::AssignmentPropertyContext::AssignmentPropertyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t FormalParser::AssignmentPropertyContext::getRuleIndex() const {
  return FormalParser::RuleAssignmentProperty;
}

size_t FormalParser::AssignmentPropertyContext::getContextId() const {
  return FormalParser::ContextIdAssignmentProperty;
}

void FormalParser::AssignmentPropertyContext::copyFrom(AssignmentPropertyContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
  this->type = ctx->type;
  this->method = ctx->method;
  this->shorthand = ctx->shorthand;
  this->computed = ctx->computed;
  this->kind = ctx->kind;
}

//----------------- ShorthandAssignmentPropertyContext ------------------------------------------------------------------

FormalParser::PropertyKeyContext* FormalParser::ShorthandAssignmentPropertyContext::propertyKey() {
  return getRuleContext<FormalParser::PropertyKeyContext>(0);
}


size_t FormalParser::ShorthandAssignmentPropertyContext::getContextId() const {
  return FormalParser::ContextIdShorthandAssignmentProperty;
}

FormalParser::ShorthandAssignmentPropertyContext::ShorthandAssignmentPropertyContext(AssignmentPropertyContext *ctx) { copyFrom(ctx); }


//----------------- AssignmentPatternInObjectContext ------------------------------------------------------------------

FormalParser::AssignmentPatternContext* FormalParser::AssignmentPatternInObjectContext::assignmentPattern() {
  return getRuleContext<FormalParser::AssignmentPatternContext>(0);
}


size_t FormalParser::AssignmentPatternInObjectContext::getContextId() const {
  return FormalParser::ContextIdAssignmentPatternInObject;
}

FormalParser::AssignmentPatternInObjectContext::AssignmentPatternInObjectContext(AssignmentPropertyContext *ctx) { copyFrom(ctx); }


FormalParser::AssignmentPropertyContext* FormalParser::assignmentProperty() {
  AssignmentPropertyContext *_localctx = _tracker.createInstance<AssignmentPropertyContext>(_ctx, getState());
  enterRule(_localctx, 134, FormalParser::RuleAssignmentProperty);

          dynamic_cast<AssignmentPropertyContext *>(_localctx)->type =  "Property";
          dynamic_cast<AssignmentPropertyContext *>(_localctx)->kind =  "init";
          dynamic_cast<AssignmentPropertyContext *>(_localctx)->method =  false;



  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1070);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx)) {
    case 1: {
      _localctx = dynamic_cast<AssignmentPropertyContext *>(_tracker.createInstance<FormalParser::ShorthandAssignmentPropertyContext>(_localctx));
      enterOuterAlt(_localctx, 1);
      setState(1064);
      dynamic_cast<ShorthandAssignmentPropertyContext *>(_localctx)->key_ = propertyKey();
       
              //NOTE the peroperty value is the same with key in ShorthandAssignmentProperty
              dynamic_cast<ShorthandAssignmentPropertyContext *>(_localctx)->shorthand =  true;
              dynamic_cast<ShorthandAssignmentPropertyContext *>(_localctx)->computed =  false;

          
      break;
    }

    case 2: {
      _localctx = dynamic_cast<AssignmentPropertyContext *>(_tracker.createInstance<FormalParser::AssignmentPatternInObjectContext>(_localctx));
      enterOuterAlt(_localctx, 2);
      setState(1067);
      dynamic_cast<AssignmentPatternInObjectContext *>(_localctx)->value_ = assignmentPattern();

              //NOTE the peroperty key with assignmentPattern in AssignmentPatternInObject is the lhs of the assignmentPattern 
              dynamic_cast<AssignmentPatternInObjectContext *>(_localctx)->shorthand =  false;
              dynamic_cast<AssignmentPatternInObjectContext *>(_localctx)->computed =  false;
          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ObjectPatternElementContext ------------------------------------------------------------------

FormalParser::ObjectPatternElementContext::ObjectPatternElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::AssignmentPropertyContext* FormalParser::ObjectPatternElementContext::assignmentProperty() {
  return getRuleContext<FormalParser::AssignmentPropertyContext>(0);
}

FormalParser::SpreadElementContext* FormalParser::ObjectPatternElementContext::spreadElement() {
  return getRuleContext<FormalParser::SpreadElementContext>(0);
}


size_t FormalParser::ObjectPatternElementContext::getRuleIndex() const {
  return FormalParser::RuleObjectPatternElement;
}

size_t FormalParser::ObjectPatternElementContext::getContextId() const {
  return FormalParser::ContextIdObjectPatternElement;
}


FormalParser::ObjectPatternElementContext* FormalParser::objectPatternElement() {
  ObjectPatternElementContext *_localctx = _tracker.createInstance<ObjectPatternElementContext>(_ctx, getState());
  enterRule(_localctx, 136, FormalParser::RuleObjectPatternElement);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1074);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1072);
      assignmentProperty();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1073);
      spreadElement();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ObjectPatternElementArrayListContext ------------------------------------------------------------------

FormalParser::ObjectPatternElementArrayListContext::ObjectPatternElementArrayListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::ObjectPatternElementContext *> FormalParser::ObjectPatternElementArrayListContext::objectPatternElement() {
  return getRuleContexts<FormalParser::ObjectPatternElementContext>();
}

FormalParser::ObjectPatternElementContext* FormalParser::ObjectPatternElementArrayListContext::objectPatternElement(size_t i) {
  return getRuleContext<FormalParser::ObjectPatternElementContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::ObjectPatternElementArrayListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::ObjectPatternElementArrayListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::ObjectPatternElementArrayListContext::getRuleIndex() const {
  return FormalParser::RuleObjectPatternElementArrayList;
}

size_t FormalParser::ObjectPatternElementArrayListContext::getContextId() const {
  return FormalParser::ContextIdObjectPatternElementArrayList;
}


FormalParser::ObjectPatternElementArrayListContext* FormalParser::objectPatternElementArrayList() {
  ObjectPatternElementArrayListContext *_localctx = _tracker.createInstance<ObjectPatternElementArrayListContext>(_ctx, getState());
  enterRule(_localctx, 138, FormalParser::RuleObjectPatternElementArrayList);

  	    dynamic_cast<ObjectPatternElementArrayListContext *>(_localctx)->isArrayList =  true;

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1076);
    objectPatternElement();
    setState(1081);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 121, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1077);
        match(FormalParser::Comma);
        setState(1078);
        objectPatternElement(); 
      }
      setState(1083);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 121, _ctx);
    }
    setState(1085);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Comma) {
      setState(1084);
      match(FormalParser::Comma);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GetAccessorContext ------------------------------------------------------------------

FormalParser::GetAccessorContext::GetAccessorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::GetAccessorContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::GetAccessorContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

tree::TerminalNode* FormalParser::GetAccessorContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::GetAccessorContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::GetterContext* FormalParser::GetAccessorContext::getter() {
  return getRuleContext<FormalParser::GetterContext>(0);
}

FormalParser::FunctionBodyContext* FormalParser::GetAccessorContext::functionBody() {
  return getRuleContext<FormalParser::FunctionBodyContext>(0);
}

FormalParser::TypeAnnotationContext* FormalParser::GetAccessorContext::typeAnnotation() {
  return getRuleContext<FormalParser::TypeAnnotationContext>(0);
}


size_t FormalParser::GetAccessorContext::getRuleIndex() const {
  return FormalParser::RuleGetAccessor;
}

size_t FormalParser::GetAccessorContext::getContextId() const {
  return FormalParser::ContextIdGetAccessor;
}


FormalParser::GetAccessorContext* FormalParser::getAccessor() {
  GetAccessorContext *_localctx = _tracker.createInstance<GetAccessorContext>(_ctx, getState());
  enterRule(_localctx, 140, FormalParser::RuleGetAccessor);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1087);
    dynamic_cast<GetAccessorContext *>(_localctx)->getter_ = getter();
    setState(1088);
    match(FormalParser::OpenParen);
    setState(1089);
    match(FormalParser::CloseParen);
    setState(1091);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Colon) {
      setState(1090);
      dynamic_cast<GetAccessorContext *>(_localctx)->typeAnnotation_ = typeAnnotation();
    }
    setState(1093);
    match(FormalParser::OpenBrace);
    setState(1094);
    dynamic_cast<GetAccessorContext *>(_localctx)->body_ = functionBody();
    setState(1095);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetAccessorContext ------------------------------------------------------------------

FormalParser::SetAccessorContext::SetAccessorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::SetAccessorContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::SetAccessorContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

tree::TerminalNode* FormalParser::SetAccessorContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::SetAccessorContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::SetterContext* FormalParser::SetAccessorContext::setter() {
  return getRuleContext<FormalParser::SetterContext>(0);
}

FormalParser::FunctionBodyContext* FormalParser::SetAccessorContext::functionBody() {
  return getRuleContext<FormalParser::FunctionBodyContext>(0);
}

FormalParser::IdentifierContext* FormalParser::SetAccessorContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::PatternContext* FormalParser::SetAccessorContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

FormalParser::TypeAnnotationContext* FormalParser::SetAccessorContext::typeAnnotation() {
  return getRuleContext<FormalParser::TypeAnnotationContext>(0);
}


size_t FormalParser::SetAccessorContext::getRuleIndex() const {
  return FormalParser::RuleSetAccessor;
}

size_t FormalParser::SetAccessorContext::getContextId() const {
  return FormalParser::ContextIdSetAccessor;
}


FormalParser::SetAccessorContext* FormalParser::setAccessor() {
  SetAccessorContext *_localctx = _tracker.createInstance<SetAccessorContext>(_ctx, getState());
  enterRule(_localctx, 142, FormalParser::RuleSetAccessor);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1097);
    dynamic_cast<SetAccessorContext *>(_localctx)->setter_ = setter();
    setState(1098);
    match(FormalParser::OpenParen);
    setState(1101);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 124, _ctx)) {
    case 1: {
      setState(1099);
      dynamic_cast<SetAccessorContext *>(_localctx)->id_ = identifier();
      break;
    }

    case 2: {
      setState(1100);
      dynamic_cast<SetAccessorContext *>(_localctx)->pattern_ = pattern();
      break;
    }

    }
    setState(1104);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FormalParser::Colon) {
      setState(1103);
      dynamic_cast<SetAccessorContext *>(_localctx)->typeAnnotation_ = typeAnnotation();
    }
    setState(1106);
    match(FormalParser::CloseParen);
    setState(1107);
    match(FormalParser::OpenBrace);
    setState(1108);
    dynamic_cast<SetAccessorContext *>(_localctx)->body_ = functionBody();
    setState(1109);
    match(FormalParser::CloseBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgumentArrayListContext ------------------------------------------------------------------

FormalParser::ArgumentArrayListContext::ArgumentArrayListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::ArgumentContext *> FormalParser::ArgumentArrayListContext::argument() {
  return getRuleContexts<FormalParser::ArgumentContext>();
}

FormalParser::ArgumentContext* FormalParser::ArgumentArrayListContext::argument(size_t i) {
  return getRuleContext<FormalParser::ArgumentContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::ArgumentArrayListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::ArgumentArrayListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::ArgumentArrayListContext::getRuleIndex() const {
  return FormalParser::RuleArgumentArrayList;
}

size_t FormalParser::ArgumentArrayListContext::getContextId() const {
  return FormalParser::ContextIdArgumentArrayList;
}


FormalParser::ArgumentArrayListContext* FormalParser::argumentArrayList() {
  ArgumentArrayListContext *_localctx = _tracker.createInstance<ArgumentArrayListContext>(_ctx, getState());
  enterRule(_localctx, 144, FormalParser::RuleArgumentArrayList);

  	    dynamic_cast<ArgumentArrayListContext *>(_localctx)->isArrayList =  true;

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1111);
    argument();
    setState(1116);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::Comma) {
      setState(1112);
      match(FormalParser::Comma);
      setState(1113);
      argument();
      setState(1118);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgumentContext ------------------------------------------------------------------

FormalParser::ArgumentContext::ArgumentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::SpreadElementContext* FormalParser::ArgumentContext::spreadElement() {
  return getRuleContext<FormalParser::SpreadElementContext>(0);
}

FormalParser::ExpressionContext* FormalParser::ArgumentContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::ArgumentContext::getRuleIndex() const {
  return FormalParser::RuleArgument;
}

size_t FormalParser::ArgumentContext::getContextId() const {
  return FormalParser::ContextIdArgument;
}


FormalParser::ArgumentContext* FormalParser::argument() {
  ArgumentContext *_localctx = _tracker.createInstance<ArgumentContext>(_ctx, getState());
  enterRule(_localctx, 146, FormalParser::RuleArgument);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1121);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1119);
      spreadElement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1120);
      expression(0);
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExpressionSequenceContext ------------------------------------------------------------------

FormalParser::ExpressionSequenceContext::ExpressionSequenceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::ExpressionContext *> FormalParser::ExpressionSequenceContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::ExpressionSequenceContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::ExpressionSequenceContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::ExpressionSequenceContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::ExpressionSequenceContext::getRuleIndex() const {
  return FormalParser::RuleExpressionSequence;
}

size_t FormalParser::ExpressionSequenceContext::getContextId() const {
  return FormalParser::ContextIdExpressionSequence;
}


FormalParser::ExpressionSequenceContext* FormalParser::expressionSequence() {
  ExpressionSequenceContext *_localctx = _tracker.createInstance<ExpressionSequenceContext>(_ctx, getState());
  enterRule(_localctx, 148, FormalParser::RuleExpressionSequence);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1123);
    expression(0);
    setState(1128);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1124);
        match(FormalParser::Comma);
        setState(1125);
        expression(0); 
      }
      setState(1130);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx);
    }
     
            dynamic_cast<ExpressionSequenceContext *>(_localctx)->type =  "SequenceExpression";
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UpdateOperatorContext ------------------------------------------------------------------

FormalParser::UpdateOperatorContext::UpdateOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::UpdateOperatorContext::PlusPlus() {
  return getToken(FormalParser::PlusPlus, 0);
}

tree::TerminalNode* FormalParser::UpdateOperatorContext::MinusMinus() {
  return getToken(FormalParser::MinusMinus, 0);
}


size_t FormalParser::UpdateOperatorContext::getRuleIndex() const {
  return FormalParser::RuleUpdateOperator;
}

size_t FormalParser::UpdateOperatorContext::getContextId() const {
  return FormalParser::ContextIdUpdateOperator;
}


FormalParser::UpdateOperatorContext* FormalParser::updateOperator() {
  UpdateOperatorContext *_localctx = _tracker.createInstance<UpdateOperatorContext>(_ctx, getState());
  enterRule(_localctx, 150, FormalParser::RuleUpdateOperator);

          dynamic_cast<UpdateOperatorContext *>(_localctx)->type =  "UpdateOperator";
          dynamic_cast<UpdateOperatorContext *>(_localctx)->prefix =  false;


  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1133);
    _la = _input->LA(1);
    if (!(_la == FormalParser::PlusPlus

    || _la == FormalParser::MinusMinus)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UnaryOperatorContext ------------------------------------------------------------------

FormalParser::UnaryOperatorContext::UnaryOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::UnaryOperatorContext::Minus() {
  return getToken(FormalParser::Minus, 0);
}

tree::TerminalNode* FormalParser::UnaryOperatorContext::Plus() {
  return getToken(FormalParser::Plus, 0);
}

tree::TerminalNode* FormalParser::UnaryOperatorContext::Not() {
  return getToken(FormalParser::Not, 0);
}

tree::TerminalNode* FormalParser::UnaryOperatorContext::BitNot() {
  return getToken(FormalParser::BitNot, 0);
}

tree::TerminalNode* FormalParser::UnaryOperatorContext::Typeof() {
  return getToken(FormalParser::Typeof, 0);
}

tree::TerminalNode* FormalParser::UnaryOperatorContext::Void() {
  return getToken(FormalParser::Void, 0);
}

tree::TerminalNode* FormalParser::UnaryOperatorContext::Delete() {
  return getToken(FormalParser::Delete, 0);
}


size_t FormalParser::UnaryOperatorContext::getRuleIndex() const {
  return FormalParser::RuleUnaryOperator;
}

size_t FormalParser::UnaryOperatorContext::getContextId() const {
  return FormalParser::ContextIdUnaryOperator;
}


FormalParser::UnaryOperatorContext* FormalParser::unaryOperator() {
  UnaryOperatorContext *_localctx = _tracker.createInstance<UnaryOperatorContext>(_ctx, getState());
  enterRule(_localctx, 152, FormalParser::RuleUnaryOperator);

          dynamic_cast<UnaryOperatorContext *>(_localctx)->type =  "UnaryOperator";
          dynamic_cast<UnaryOperatorContext *>(_localctx)->prefix =  true;


  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1135);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << FormalParser::Plus)
      | (1ULL << FormalParser::Minus)
      | (1ULL << FormalParser::BitNot)
      | (1ULL << FormalParser::Not))) != 0) || ((((_la - 71) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 71)) & ((1ULL << (FormalParser::Typeof - 71))
      | (1ULL << (FormalParser::Void - 71))
      | (1ULL << (FormalParser::Delete - 71)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExponentiationOperatorContext ------------------------------------------------------------------

FormalParser::ExponentiationOperatorContext::ExponentiationOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ExponentiationOperatorContext::Exponentiation() {
  return getToken(FormalParser::Exponentiation, 0);
}


size_t FormalParser::ExponentiationOperatorContext::getRuleIndex() const {
  return FormalParser::RuleExponentiationOperator;
}

size_t FormalParser::ExponentiationOperatorContext::getContextId() const {
  return FormalParser::ContextIdExponentiationOperator;
}


FormalParser::ExponentiationOperatorContext* FormalParser::exponentiationOperator() {
  ExponentiationOperatorContext *_localctx = _tracker.createInstance<ExponentiationOperatorContext>(_ctx, getState());
  enterRule(_localctx, 154, FormalParser::RuleExponentiationOperator);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1137);
    match(FormalParser::Exponentiation);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MultiplicativeOperatorContext ------------------------------------------------------------------

FormalParser::MultiplicativeOperatorContext::MultiplicativeOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::MultiplicativeOperatorContext::Multiply() {
  return getToken(FormalParser::Multiply, 0);
}

tree::TerminalNode* FormalParser::MultiplicativeOperatorContext::Divide() {
  return getToken(FormalParser::Divide, 0);
}

tree::TerminalNode* FormalParser::MultiplicativeOperatorContext::Modulus() {
  return getToken(FormalParser::Modulus, 0);
}


size_t FormalParser::MultiplicativeOperatorContext::getRuleIndex() const {
  return FormalParser::RuleMultiplicativeOperator;
}

size_t FormalParser::MultiplicativeOperatorContext::getContextId() const {
  return FormalParser::ContextIdMultiplicativeOperator;
}


FormalParser::MultiplicativeOperatorContext* FormalParser::multiplicativeOperator() {
  MultiplicativeOperatorContext *_localctx = _tracker.createInstance<MultiplicativeOperatorContext>(_ctx, getState());
  enterRule(_localctx, 156, FormalParser::RuleMultiplicativeOperator);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1139);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << FormalParser::Multiply)
      | (1ULL << FormalParser::Divide)
      | (1ULL << FormalParser::Modulus))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AdditiveOperatorContext ------------------------------------------------------------------

FormalParser::AdditiveOperatorContext::AdditiveOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::AdditiveOperatorContext::Plus() {
  return getToken(FormalParser::Plus, 0);
}

tree::TerminalNode* FormalParser::AdditiveOperatorContext::Minus() {
  return getToken(FormalParser::Minus, 0);
}


size_t FormalParser::AdditiveOperatorContext::getRuleIndex() const {
  return FormalParser::RuleAdditiveOperator;
}

size_t FormalParser::AdditiveOperatorContext::getContextId() const {
  return FormalParser::ContextIdAdditiveOperator;
}


FormalParser::AdditiveOperatorContext* FormalParser::additiveOperator() {
  AdditiveOperatorContext *_localctx = _tracker.createInstance<AdditiveOperatorContext>(_ctx, getState());
  enterRule(_localctx, 158, FormalParser::RuleAdditiveOperator);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1141);
    _la = _input->LA(1);
    if (!(_la == FormalParser::Plus

    || _la == FormalParser::Minus)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BitShiftOperatorContext ------------------------------------------------------------------

FormalParser::BitShiftOperatorContext::BitShiftOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::BitShiftOperatorContext::LeftShiftArithmetic() {
  return getToken(FormalParser::LeftShiftArithmetic, 0);
}

tree::TerminalNode* FormalParser::BitShiftOperatorContext::RightShiftArithmetic() {
  return getToken(FormalParser::RightShiftArithmetic, 0);
}

tree::TerminalNode* FormalParser::BitShiftOperatorContext::RightShiftLogical() {
  return getToken(FormalParser::RightShiftLogical, 0);
}


size_t FormalParser::BitShiftOperatorContext::getRuleIndex() const {
  return FormalParser::RuleBitShiftOperator;
}

size_t FormalParser::BitShiftOperatorContext::getContextId() const {
  return FormalParser::ContextIdBitShiftOperator;
}


FormalParser::BitShiftOperatorContext* FormalParser::bitShiftOperator() {
  BitShiftOperatorContext *_localctx = _tracker.createInstance<BitShiftOperatorContext>(_ctx, getState());
  enterRule(_localctx, 160, FormalParser::RuleBitShiftOperator);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1143);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << FormalParser::RightShiftArithmetic)
      | (1ULL << FormalParser::LeftShiftArithmetic)
      | (1ULL << FormalParser::RightShiftLogical))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RelationalOperatorContext ------------------------------------------------------------------

FormalParser::RelationalOperatorContext::RelationalOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::RelationalOperatorContext::LessThan() {
  return getToken(FormalParser::LessThan, 0);
}

tree::TerminalNode* FormalParser::RelationalOperatorContext::MoreThan() {
  return getToken(FormalParser::MoreThan, 0);
}

tree::TerminalNode* FormalParser::RelationalOperatorContext::LessThanEquals() {
  return getToken(FormalParser::LessThanEquals, 0);
}

tree::TerminalNode* FormalParser::RelationalOperatorContext::GreaterThanEquals() {
  return getToken(FormalParser::GreaterThanEquals, 0);
}


size_t FormalParser::RelationalOperatorContext::getRuleIndex() const {
  return FormalParser::RuleRelationalOperator;
}

size_t FormalParser::RelationalOperatorContext::getContextId() const {
  return FormalParser::ContextIdRelationalOperator;
}


FormalParser::RelationalOperatorContext* FormalParser::relationalOperator() {
  RelationalOperatorContext *_localctx = _tracker.createInstance<RelationalOperatorContext>(_ctx, getState());
  enterRule(_localctx, 162, FormalParser::RuleRelationalOperator);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1145);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << FormalParser::LessThan)
      | (1ULL << FormalParser::MoreThan)
      | (1ULL << FormalParser::LessThanEquals)
      | (1ULL << FormalParser::GreaterThanEquals))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InstanceofOperatorContext ------------------------------------------------------------------

FormalParser::InstanceofOperatorContext::InstanceofOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::InstanceofOperatorContext::Instanceof() {
  return getToken(FormalParser::Instanceof, 0);
}


size_t FormalParser::InstanceofOperatorContext::getRuleIndex() const {
  return FormalParser::RuleInstanceofOperator;
}

size_t FormalParser::InstanceofOperatorContext::getContextId() const {
  return FormalParser::ContextIdInstanceofOperator;
}


FormalParser::InstanceofOperatorContext* FormalParser::instanceofOperator() {
  InstanceofOperatorContext *_localctx = _tracker.createInstance<InstanceofOperatorContext>(_ctx, getState());
  enterRule(_localctx, 164, FormalParser::RuleInstanceofOperator);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1147);
    match(FormalParser::Instanceof);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InOperatorContext ------------------------------------------------------------------

FormalParser::InOperatorContext::InOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::InOperatorContext::In() {
  return getToken(FormalParser::In, 0);
}


size_t FormalParser::InOperatorContext::getRuleIndex() const {
  return FormalParser::RuleInOperator;
}

size_t FormalParser::InOperatorContext::getContextId() const {
  return FormalParser::ContextIdInOperator;
}


FormalParser::InOperatorContext* FormalParser::inOperator() {
  InOperatorContext *_localctx = _tracker.createInstance<InOperatorContext>(_ctx, getState());
  enterRule(_localctx, 166, FormalParser::RuleInOperator);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1149);
    match(FormalParser::In);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EqualityOperatorContext ------------------------------------------------------------------

FormalParser::EqualityOperatorContext::EqualityOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::EqualityOperatorContext::Equals_() {
  return getToken(FormalParser::Equals_, 0);
}

tree::TerminalNode* FormalParser::EqualityOperatorContext::NotEquals() {
  return getToken(FormalParser::NotEquals, 0);
}

tree::TerminalNode* FormalParser::EqualityOperatorContext::IdentityEquals() {
  return getToken(FormalParser::IdentityEquals, 0);
}


size_t FormalParser::EqualityOperatorContext::getRuleIndex() const {
  return FormalParser::RuleEqualityOperator;
}

size_t FormalParser::EqualityOperatorContext::getContextId() const {
  return FormalParser::ContextIdEqualityOperator;
}


FormalParser::EqualityOperatorContext* FormalParser::equalityOperator() {
  EqualityOperatorContext *_localctx = _tracker.createInstance<EqualityOperatorContext>(_ctx, getState());
  enterRule(_localctx, 168, FormalParser::RuleEqualityOperator);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1151);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << FormalParser::Equals_)
      | (1ULL << FormalParser::NotEquals)
      | (1ULL << FormalParser::IdentityEquals))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BitAndOperatorContext ------------------------------------------------------------------

FormalParser::BitAndOperatorContext::BitAndOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::BitAndOperatorContext::BitAnd() {
  return getToken(FormalParser::BitAnd, 0);
}


size_t FormalParser::BitAndOperatorContext::getRuleIndex() const {
  return FormalParser::RuleBitAndOperator;
}

size_t FormalParser::BitAndOperatorContext::getContextId() const {
  return FormalParser::ContextIdBitAndOperator;
}


FormalParser::BitAndOperatorContext* FormalParser::bitAndOperator() {
  BitAndOperatorContext *_localctx = _tracker.createInstance<BitAndOperatorContext>(_ctx, getState());
  enterRule(_localctx, 170, FormalParser::RuleBitAndOperator);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1153);
    match(FormalParser::BitAnd);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BitOrOperatorContext ------------------------------------------------------------------

FormalParser::BitOrOperatorContext::BitOrOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::BitOrOperatorContext::BitOr() {
  return getToken(FormalParser::BitOr, 0);
}


size_t FormalParser::BitOrOperatorContext::getRuleIndex() const {
  return FormalParser::RuleBitOrOperator;
}

size_t FormalParser::BitOrOperatorContext::getContextId() const {
  return FormalParser::ContextIdBitOrOperator;
}


FormalParser::BitOrOperatorContext* FormalParser::bitOrOperator() {
  BitOrOperatorContext *_localctx = _tracker.createInstance<BitOrOperatorContext>(_ctx, getState());
  enterRule(_localctx, 172, FormalParser::RuleBitOrOperator);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1155);
    match(FormalParser::BitOr);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BitXorOperatorContext ------------------------------------------------------------------

FormalParser::BitXorOperatorContext::BitXorOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::BitXorOperatorContext::BitXOr() {
  return getToken(FormalParser::BitXOr, 0);
}


size_t FormalParser::BitXorOperatorContext::getRuleIndex() const {
  return FormalParser::RuleBitXorOperator;
}

size_t FormalParser::BitXorOperatorContext::getContextId() const {
  return FormalParser::ContextIdBitXorOperator;
}


FormalParser::BitXorOperatorContext* FormalParser::bitXorOperator() {
  BitXorOperatorContext *_localctx = _tracker.createInstance<BitXorOperatorContext>(_ctx, getState());
  enterRule(_localctx, 174, FormalParser::RuleBitXorOperator);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1157);
    match(FormalParser::BitXOr);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExpressionContext ------------------------------------------------------------------

FormalParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t FormalParser::ExpressionContext::getRuleIndex() const {
  return FormalParser::RuleExpression;
}

size_t FormalParser::ExpressionContext::getContextId() const {
  return FormalParser::ContextIdExpression;
}

void FormalParser::ExpressionContext::copyFrom(ExpressionContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
  this->type = ctx->type;
}

//----------------- GeneratorsExpressionContext ------------------------------------------------------------------

FormalParser::GeneratorBlockContext* FormalParser::GeneratorsExpressionContext::generatorBlock() {
  return getRuleContext<FormalParser::GeneratorBlockContext>(0);
}


size_t FormalParser::GeneratorsExpressionContext::getContextId() const {
  return FormalParser::ContextIdGeneratorsExpression;
}

FormalParser::GeneratorsExpressionContext::GeneratorsExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ExponentiationExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::ExponentiationExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::ExponentiationExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::ExponentiationOperatorContext* FormalParser::ExponentiationExpressionContext::exponentiationOperator() {
  return getRuleContext<FormalParser::ExponentiationOperatorContext>(0);
}


size_t FormalParser::ExponentiationExpressionContext::getContextId() const {
  return FormalParser::ContextIdExponentiationExpression;
}

FormalParser::ExponentiationExpressionContext::ExponentiationExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- PatternInvolvedAssignmentExpressionContext ------------------------------------------------------------------

FormalParser::PatternContext* FormalParser::PatternInvolvedAssignmentExpressionContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

FormalParser::AssignmentOperatorContext* FormalParser::PatternInvolvedAssignmentExpressionContext::assignmentOperator() {
  return getRuleContext<FormalParser::AssignmentOperatorContext>(0);
}

FormalParser::ExpressionContext* FormalParser::PatternInvolvedAssignmentExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::PatternInvolvedAssignmentExpressionContext::getContextId() const {
  return FormalParser::ContextIdPatternInvolvedAssignmentExpression;
}

FormalParser::PatternInvolvedAssignmentExpressionContext::PatternInvolvedAssignmentExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- InExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::InExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::InExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::InOperatorContext* FormalParser::InExpressionContext::inOperator() {
  return getRuleContext<FormalParser::InOperatorContext>(0);
}


size_t FormalParser::InExpressionContext::getContextId() const {
  return FormalParser::ContextIdInExpression;
}

FormalParser::InExpressionContext::InExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- UnaryExpressionContext ------------------------------------------------------------------

FormalParser::UnaryOperatorContext* FormalParser::UnaryExpressionContext::unaryOperator() {
  return getRuleContext<FormalParser::UnaryOperatorContext>(0);
}

FormalParser::ExpressionContext* FormalParser::UnaryExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::UnaryExpressionContext::getContextId() const {
  return FormalParser::ContextIdUnaryExpression;
}

FormalParser::UnaryExpressionContext::UnaryExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- AwaitExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::AwaitExpressionContext::Await() {
  return getToken(FormalParser::Await, 0);
}

FormalParser::ExpressionContext* FormalParser::AwaitExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::AwaitExpressionContext::getContextId() const {
  return FormalParser::ContextIdAwaitExpression;
}

FormalParser::AwaitExpressionContext::AwaitExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ThisExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ThisExpressionContext::This() {
  return getToken(FormalParser::This, 0);
}


size_t FormalParser::ThisExpressionContext::getContextId() const {
  return FormalParser::ContextIdThisExpression;
}

FormalParser::ThisExpressionContext::ThisExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- LogicalExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::LogicalExpressionContext::And() {
  return getToken(FormalParser::And, 0);
}

std::vector<FormalParser::ExpressionContext *> FormalParser::LogicalExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::LogicalExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

tree::TerminalNode* FormalParser::LogicalExpressionContext::Or() {
  return getToken(FormalParser::Or, 0);
}

tree::TerminalNode* FormalParser::LogicalExpressionContext::DoubleQuestionMark() {
  return getToken(FormalParser::DoubleQuestionMark, 0);
}


size_t FormalParser::LogicalExpressionContext::getContextId() const {
  return FormalParser::ContextIdLogicalExpression;
}

FormalParser::LogicalExpressionContext::LogicalExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- FunctionExpressionContext ------------------------------------------------------------------

FormalParser::BaseFunctionContext* FormalParser::FunctionExpressionContext::baseFunction() {
  return getRuleContext<FormalParser::BaseFunctionContext>(0);
}

FormalParser::BraceBlockContext* FormalParser::FunctionExpressionContext::braceBlock() {
  return getRuleContext<FormalParser::BraceBlockContext>(0);
}


size_t FormalParser::FunctionExpressionContext::getContextId() const {
  return FormalParser::ContextIdFunctionExpression;
}

FormalParser::FunctionExpressionContext::FunctionExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- AssignmentExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::AssignmentExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::AssignmentExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::AssignmentOperatorContext* FormalParser::AssignmentExpressionContext::assignmentOperator() {
  return getRuleContext<FormalParser::AssignmentOperatorContext>(0);
}


size_t FormalParser::AssignmentExpressionContext::getContextId() const {
  return FormalParser::ContextIdAssignmentExpression;
}

FormalParser::AssignmentExpressionContext::AssignmentExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- TaggedTemplateExpressionContext ------------------------------------------------------------------

FormalParser::ExpressionContext* FormalParser::TaggedTemplateExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}

FormalParser::TemplateLiteralContext* FormalParser::TaggedTemplateExpressionContext::templateLiteral() {
  return getRuleContext<FormalParser::TemplateLiteralContext>(0);
}


size_t FormalParser::TaggedTemplateExpressionContext::getContextId() const {
  return FormalParser::ContextIdTaggedTemplateExpression;
}

FormalParser::TaggedTemplateExpressionContext::TaggedTemplateExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- InstanceofExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::InstanceofExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::InstanceofExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::InstanceofOperatorContext* FormalParser::InstanceofExpressionContext::instanceofOperator() {
  return getRuleContext<FormalParser::InstanceofOperatorContext>(0);
}


size_t FormalParser::InstanceofExpressionContext::getContextId() const {
  return FormalParser::ContextIdInstanceofExpression;
}

FormalParser::InstanceofExpressionContext::InstanceofExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- GeneratorsFunctionExpressionContext ------------------------------------------------------------------

FormalParser::GeneratorFunctionDeclarationContext* FormalParser::GeneratorsFunctionExpressionContext::generatorFunctionDeclaration() {
  return getRuleContext<FormalParser::GeneratorFunctionDeclarationContext>(0);
}


size_t FormalParser::GeneratorsFunctionExpressionContext::getContextId() const {
  return FormalParser::ContextIdGeneratorsFunctionExpression;
}

FormalParser::GeneratorsFunctionExpressionContext::GeneratorsFunctionExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ImportExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ImportExpressionContext::Import() {
  return getToken(FormalParser::Import, 0);
}

tree::TerminalNode* FormalParser::ImportExpressionContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::ImportExpressionContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ExpressionContext* FormalParser::ImportExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::ImportExpressionContext::getContextId() const {
  return FormalParser::ContextIdImportExpression;
}

FormalParser::ImportExpressionContext::ImportExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ArrowFunctionExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ArrowFunctionExpressionContext::ARROW() {
  return getToken(FormalParser::ARROW, 0);
}

FormalParser::ArrowFunctionParametersContext* FormalParser::ArrowFunctionExpressionContext::arrowFunctionParameters() {
  return getRuleContext<FormalParser::ArrowFunctionParametersContext>(0);
}

FormalParser::ArrowFunctionBodyContext* FormalParser::ArrowFunctionExpressionContext::arrowFunctionBody() {
  return getRuleContext<FormalParser::ArrowFunctionBodyContext>(0);
}

tree::TerminalNode* FormalParser::ArrowFunctionExpressionContext::Async() {
  return getToken(FormalParser::Async, 0);
}

FormalParser::FunctionReturnTypeContext* FormalParser::ArrowFunctionExpressionContext::functionReturnType() {
  return getRuleContext<FormalParser::FunctionReturnTypeContext>(0);
}


size_t FormalParser::ArrowFunctionExpressionContext::getContextId() const {
  return FormalParser::ContextIdArrowFunctionExpression;
}

FormalParser::ArrowFunctionExpressionContext::ArrowFunctionExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- IteratorsExpressionContext ------------------------------------------------------------------

FormalParser::IteratorBlockContext* FormalParser::IteratorsExpressionContext::iteratorBlock() {
  return getRuleContext<FormalParser::IteratorBlockContext>(0);
}


size_t FormalParser::IteratorsExpressionContext::getContextId() const {
  return FormalParser::ContextIdIteratorsExpression;
}

FormalParser::IteratorsExpressionContext::IteratorsExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- MetaPropertyContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::MetaPropertyContext::Dot() {
  return getToken(FormalParser::Dot, 0);
}

FormalParser::MetaPropertyIdentifierContext* FormalParser::MetaPropertyContext::metaPropertyIdentifier() {
  return getRuleContext<FormalParser::MetaPropertyIdentifierContext>(0);
}

FormalParser::IdentifierContext* FormalParser::MetaPropertyContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}


size_t FormalParser::MetaPropertyContext::getContextId() const {
  return FormalParser::ContextIdMetaProperty;
}

FormalParser::MetaPropertyContext::MetaPropertyContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- EqualityExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::EqualityExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::EqualityExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::EqualityOperatorContext* FormalParser::EqualityExpressionContext::equalityOperator() {
  return getRuleContext<FormalParser::EqualityOperatorContext>(0);
}


size_t FormalParser::EqualityExpressionContext::getContextId() const {
  return FormalParser::ContextIdEqualityExpression;
}

FormalParser::EqualityExpressionContext::EqualityExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- UpdateExpressionContext ------------------------------------------------------------------

FormalParser::UpdateOperatorContext* FormalParser::UpdateExpressionContext::updateOperator() {
  return getRuleContext<FormalParser::UpdateOperatorContext>(0);
}

FormalParser::ExpressionContext* FormalParser::UpdateExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::UpdateExpressionContext::getContextId() const {
  return FormalParser::ContextIdUpdateExpression;
}

FormalParser::UpdateExpressionContext::UpdateExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- SuperExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::SuperExpressionContext::Super() {
  return getToken(FormalParser::Super, 0);
}


size_t FormalParser::SuperExpressionContext::getContextId() const {
  return FormalParser::ContextIdSuperExpression;
}

FormalParser::SuperExpressionContext::SuperExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- MultiplicativeExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::MultiplicativeExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::MultiplicativeExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::MultiplicativeOperatorContext* FormalParser::MultiplicativeExpressionContext::multiplicativeOperator() {
  return getRuleContext<FormalParser::MultiplicativeOperatorContext>(0);
}


size_t FormalParser::MultiplicativeExpressionContext::getContextId() const {
  return FormalParser::ContextIdMultiplicativeExpression;
}

FormalParser::MultiplicativeExpressionContext::MultiplicativeExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- CallExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::CallExpressionContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::CallExpressionContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ExpressionContext* FormalParser::CallExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}

tree::TerminalNode* FormalParser::CallExpressionContext::OptionalChainingOperator() {
  return getToken(FormalParser::OptionalChainingOperator, 0);
}

FormalParser::ArgumentArrayListContext* FormalParser::CallExpressionContext::argumentArrayList() {
  return getRuleContext<FormalParser::ArgumentArrayListContext>(0);
}


size_t FormalParser::CallExpressionContext::getContextId() const {
  return FormalParser::ContextIdCallExpression;
}

FormalParser::CallExpressionContext::CallExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- BitShiftExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::BitShiftExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::BitShiftExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::BitShiftOperatorContext* FormalParser::BitShiftExpressionContext::bitShiftOperator() {
  return getRuleContext<FormalParser::BitShiftOperatorContext>(0);
}


size_t FormalParser::BitShiftExpressionContext::getContextId() const {
  return FormalParser::ContextIdBitShiftExpression;
}

FormalParser::BitShiftExpressionContext::BitShiftExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ParenthesizedExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ParenthesizedExpressionContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::ParenthesizedExpressionContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ExpressionSequenceContext* FormalParser::ParenthesizedExpressionContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}


size_t FormalParser::ParenthesizedExpressionContext::getContextId() const {
  return FormalParser::ContextIdParenthesizedExpression;
}

FormalParser::ParenthesizedExpressionContext::ParenthesizedExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- AdditiveExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::AdditiveExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::AdditiveExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::AdditiveOperatorContext* FormalParser::AdditiveExpressionContext::additiveOperator() {
  return getRuleContext<FormalParser::AdditiveOperatorContext>(0);
}


size_t FormalParser::AdditiveExpressionContext::getContextId() const {
  return FormalParser::ContextIdAdditiveExpression;
}

FormalParser::AdditiveExpressionContext::AdditiveExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- RelationalExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::RelationalExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::RelationalExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::RelationalOperatorContext* FormalParser::RelationalExpressionContext::relationalOperator() {
  return getRuleContext<FormalParser::RelationalOperatorContext>(0);
}


size_t FormalParser::RelationalExpressionContext::getContextId() const {
  return FormalParser::ContextIdRelationalExpression;
}

FormalParser::RelationalExpressionContext::RelationalExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- YieldExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::YieldExpressionContext::Yield() {
  return getToken(FormalParser::Yield, 0);
}

FormalParser::ExpressionContext* FormalParser::YieldExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}

tree::TerminalNode* FormalParser::YieldExpressionContext::Multiply() {
  return getToken(FormalParser::Multiply, 0);
}


size_t FormalParser::YieldExpressionContext::getContextId() const {
  return FormalParser::ContextIdYieldExpression;
}

FormalParser::YieldExpressionContext::YieldExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext::QuestionMarkFollowedByDecimalDirectly() {
  return getToken(FormalParser::QuestionMarkFollowedByDecimalDirectly, 0);
}

tree::TerminalNode* FormalParser::QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

std::vector<FormalParser::ExpressionContext *> FormalParser::QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}


size_t FormalParser::QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext::getContextId() const {
  return FormalParser::ContextIdQuestionMarkFollowedByDecimalDirectlyConditionExpression;
}

FormalParser::QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext::QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- NewExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::NewExpressionContext::New() {
  return getToken(FormalParser::New, 0);
}

tree::TerminalNode* FormalParser::NewExpressionContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::NewExpressionContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ExpressionContext* FormalParser::NewExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}

FormalParser::ArgumentArrayListContext* FormalParser::NewExpressionContext::argumentArrayList() {
  return getRuleContext<FormalParser::ArgumentArrayListContext>(0);
}


size_t FormalParser::NewExpressionContext::getContextId() const {
  return FormalParser::ContextIdNewExpression;
}

FormalParser::NewExpressionContext::NewExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- LiteralExpressionContext ------------------------------------------------------------------

FormalParser::LiteralContext* FormalParser::LiteralExpressionContext::literal() {
  return getRuleContext<FormalParser::LiteralContext>(0);
}


size_t FormalParser::LiteralExpressionContext::getContextId() const {
  return FormalParser::ContextIdLiteralExpression;
}

FormalParser::LiteralExpressionContext::LiteralExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ConditionalExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ConditionalExpressionContext::QuestionMark() {
  return getToken(FormalParser::QuestionMark, 0);
}

tree::TerminalNode* FormalParser::ConditionalExpressionContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

std::vector<FormalParser::ExpressionContext *> FormalParser::ConditionalExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::ConditionalExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}


size_t FormalParser::ConditionalExpressionContext::getContextId() const {
  return FormalParser::ContextIdConditionalExpression;
}

FormalParser::ConditionalExpressionContext::ConditionalExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- BitXorExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::BitXorExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::BitXorExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::BitXorOperatorContext* FormalParser::BitXorExpressionContext::bitXorOperator() {
  return getRuleContext<FormalParser::BitXorOperatorContext>(0);
}


size_t FormalParser::BitXorExpressionContext::getContextId() const {
  return FormalParser::ContextIdBitXorExpression;
}

FormalParser::BitXorExpressionContext::BitXorExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ClassExpressionContext ------------------------------------------------------------------

FormalParser::BaseClassContext* FormalParser::ClassExpressionContext::baseClass() {
  return getRuleContext<FormalParser::BaseClassContext>(0);
}


size_t FormalParser::ClassExpressionContext::getContextId() const {
  return FormalParser::ContextIdClassExpression;
}

FormalParser::ClassExpressionContext::ClassExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- TSAsExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::TSAsExpressionContext::As() {
  return getToken(FormalParser::As, 0);
}

std::vector<FormalParser::ExpressionContext *> FormalParser::TSAsExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::TSAsExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::Type_Context* FormalParser::TSAsExpressionContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}

tree::TerminalNode* FormalParser::TSAsExpressionContext::OpenBracket() {
  return getToken(FormalParser::OpenBracket, 0);
}

tree::TerminalNode* FormalParser::TSAsExpressionContext::CloseBracket() {
  return getToken(FormalParser::CloseBracket, 0);
}


size_t FormalParser::TSAsExpressionContext::getContextId() const {
  return FormalParser::ContextIdTSAsExpression;
}

FormalParser::TSAsExpressionContext::TSAsExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- IdentifierExpressionContext ------------------------------------------------------------------

FormalParser::IdentifierContext* FormalParser::IdentifierExpressionContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}


size_t FormalParser::IdentifierExpressionContext::getContextId() const {
  return FormalParser::ContextIdIdentifierExpression;
}

FormalParser::IdentifierExpressionContext::IdentifierExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- MemberExpressionContext ------------------------------------------------------------------

FormalParser::ExpressionContext* FormalParser::MemberExpressionContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}

FormalParser::MemberExpressionPropertyContext* FormalParser::MemberExpressionContext::memberExpressionProperty() {
  return getRuleContext<FormalParser::MemberExpressionPropertyContext>(0);
}


size_t FormalParser::MemberExpressionContext::getContextId() const {
  return FormalParser::ContextIdMemberExpression;
}

FormalParser::MemberExpressionContext::MemberExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- BitAndExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::BitAndExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::BitAndExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::BitAndOperatorContext* FormalParser::BitAndExpressionContext::bitAndOperator() {
  return getRuleContext<FormalParser::BitAndOperatorContext>(0);
}


size_t FormalParser::BitAndExpressionContext::getContextId() const {
  return FormalParser::ContextIdBitAndExpression;
}

FormalParser::BitAndExpressionContext::BitAndExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- BitOrExpressionContext ------------------------------------------------------------------

std::vector<FormalParser::ExpressionContext *> FormalParser::BitOrExpressionContext::expression() {
  return getRuleContexts<FormalParser::ExpressionContext>();
}

FormalParser::ExpressionContext* FormalParser::BitOrExpressionContext::expression(size_t i) {
  return getRuleContext<FormalParser::ExpressionContext>(i);
}

FormalParser::BitOrOperatorContext* FormalParser::BitOrExpressionContext::bitOrOperator() {
  return getRuleContext<FormalParser::BitOrOperatorContext>(0);
}


size_t FormalParser::BitOrExpressionContext::getContextId() const {
  return FormalParser::ContextIdBitOrExpression;
}

FormalParser::BitOrExpressionContext::BitOrExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ArrayExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ArrayExpressionContext::OpenBracket() {
  return getToken(FormalParser::OpenBracket, 0);
}

tree::TerminalNode* FormalParser::ArrayExpressionContext::CloseBracket() {
  return getToken(FormalParser::CloseBracket, 0);
}

FormalParser::ArrayElementArrayListContext* FormalParser::ArrayExpressionContext::arrayElementArrayList() {
  return getRuleContext<FormalParser::ArrayElementArrayListContext>(0);
}


size_t FormalParser::ArrayExpressionContext::getContextId() const {
  return FormalParser::ContextIdArrayExpression;
}

FormalParser::ArrayExpressionContext::ArrayExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- ObjectExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ObjectExpressionContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::ObjectExpressionContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::ObjectElementArrayListContext* FormalParser::ObjectExpressionContext::objectElementArrayList() {
  return getRuleContext<FormalParser::ObjectElementArrayListContext>(0);
}


size_t FormalParser::ObjectExpressionContext::getContextId() const {
  return FormalParser::ContextIdObjectExpression;
}

FormalParser::ObjectExpressionContext::ObjectExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }


//----------------- TemplateLiteralExpressionContext ------------------------------------------------------------------

FormalParser::TemplateLiteralContext* FormalParser::TemplateLiteralExpressionContext::templateLiteral() {
  return getRuleContext<FormalParser::TemplateLiteralContext>(0);
}


size_t FormalParser::TemplateLiteralExpressionContext::getContextId() const {
  return FormalParser::ContextIdTemplateLiteralExpression;
}

FormalParser::TemplateLiteralExpressionContext::TemplateLiteralExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }



FormalParser::ExpressionContext* FormalParser::expression() {
   return expression(0);
}

FormalParser::ExpressionContext* FormalParser::expression(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FormalParser::ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, parentState);
  FormalParser::ExpressionContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 176;
  enterRecursionRule(_localctx, 176, FormalParser::RuleExpression, precedence);

    size_t _la = 0;

  auto onExit = finally([=] {
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1268);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 135, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<FunctionExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(1160);
      dynamic_cast<FunctionExpressionContext *>(_localctx)->baseFunction_ = baseFunction();
      setState(1161);
      dynamic_cast<FunctionExpressionContext *>(_localctx)->body_ = braceBlock();

              dynamic_cast<FunctionExpressionContext *>(_localctx)->type =  "FunctionExpression";
              this->leaveFunction();
          
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<ArrowFunctionExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1165);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
      case 1: {
        setState(1164);
        match(FormalParser::Async);
        break;
      }

      }
      setState(1167);
      dynamic_cast<ArrowFunctionExpressionContext *>(_localctx)->params_ = arrowFunctionParameters();
      setState(1169);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 130, _ctx)) {
      case 1: {
        setState(1168);
        dynamic_cast<ArrowFunctionExpressionContext *>(_localctx)->typeAnnotation_ = functionReturnType();
        break;
      }

      }
      setState(1171);
      match(FormalParser::ARROW);
      setState(1172);
      dynamic_cast<ArrowFunctionExpressionContext *>(_localctx)->body_ = arrowFunctionBody();

              dynamic_cast<ArrowFunctionExpressionContext *>(_localctx)->type =  "ArrowFunctionExpression";
          
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<ClassExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1175);
      baseClass();

      	
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<ParenthesizedExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1178);
      match(FormalParser::OpenParen);
      setState(1179);
      dynamic_cast<ParenthesizedExpressionContext *>(_localctx)->expression_ = expressionSequence();
      setState(1180);
      match(FormalParser::CloseParen);

              dynamic_cast<ParenthesizedExpressionContext *>(_localctx)->type =  "ParenthesizedExpression";
      	
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<NewExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1183);
      match(FormalParser::New);
      setState(1184);
      dynamic_cast<NewExpressionContext *>(_localctx)->callee = expression(0);
      setState(1185);
      match(FormalParser::OpenParen);
      setState(1187);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx)) {
      case 1: {
        setState(1186);
        dynamic_cast<NewExpressionContext *>(_localctx)->arguments_ = argumentArrayList();
        break;
      }

      }
      setState(1189);
      match(FormalParser::CloseParen);

              dynamic_cast<NewExpressionContext *>(_localctx)->type =  "NewExpression";
      		this->correctNewExpression(_localctx);
      	
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<NewExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1192);
      match(FormalParser::New);
      setState(1193);
      dynamic_cast<NewExpressionContext *>(_localctx)->callee = expression(39);

              dynamic_cast<NewExpressionContext *>(_localctx)->type =  "NewExpression";
      	
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<UpdateExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1196);
      dynamic_cast<UpdateExpressionContext *>(_localctx)->operator_ = updateOperator();
      setState(1197);
      dynamic_cast<UpdateExpressionContext *>(_localctx)->argument_ = expression(37);

              //NOTE Do not use dynamic scope while generating Cpp target before bug in template file used by StringTemplate fixed ,e.g. updateOperator::prefix = true;
              dynamic_cast<UpdateExpressionContext *>(_localctx)->type =  "UpdateExpression";
              this->updateOperatorIsPrefix(dynamic_cast<UpdateExpressionContext *>(_localctx)->operator_);
          
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<UnaryExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1200);
      dynamic_cast<UnaryExpressionContext *>(_localctx)->operator_ = unaryOperator();
      setState(1201);
      dynamic_cast<UnaryExpressionContext *>(_localctx)->argument_ = expression(36);

              //NOTE @Add unaryExpression following estree
              dynamic_cast<UnaryExpressionContext *>(_localctx)->type =  "UnaryExpression";
          
      break;
    }

    case 9: {
      _localctx = _tracker.createInstance<PatternInvolvedAssignmentExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1204);
      dynamic_cast<PatternInvolvedAssignmentExpressionContext *>(_localctx)->left_ = pattern();
      setState(1205);
      dynamic_cast<PatternInvolvedAssignmentExpressionContext *>(_localctx)->operator_ = assignmentOperator();
      setState(1206);
      dynamic_cast<PatternInvolvedAssignmentExpressionContext *>(_localctx)->right_ = expression(19);

              dynamic_cast<PatternInvolvedAssignmentExpressionContext *>(_localctx)->type =  "AssignmentExpression";
      	        this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<RVALUE_IN_ASSIGNMENT_LEFT>() , [&](){
                  return !this->expectedAssignmentParent(parentContext);
              } );   
          
      break;
    }

    case 10: {
      _localctx = _tracker.createInstance<TemplateLiteralExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1209);
      templateLiteral();

              dynamic_cast<TemplateLiteralExpressionContext *>(_localctx)->type = "TemplateLiteral";
          
      break;
    }

    case 11: {
      _localctx = _tracker.createInstance<IteratorsExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1212);
      iteratorBlock();

              dynamic_cast<IteratorsExpressionContext *>(_localctx)->type =  "IteratorsExpression";
          
      break;
    }

    case 12: {
      _localctx = _tracker.createInstance<GeneratorsExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1215);
      generatorBlock();

              dynamic_cast<GeneratorsExpressionContext *>(_localctx)->type =  "GeneratorsExpression";
          
      break;
    }

    case 13: {
      _localctx = _tracker.createInstance<GeneratorsFunctionExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1218);
      generatorFunctionDeclaration();

              dynamic_cast<GeneratorsFunctionExpressionContext *>(_localctx)->type =  "GeneratorsFunctionExpression";
          
      break;
    }

    case 14: {
      _localctx = _tracker.createInstance<YieldExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1221);
      match(FormalParser::Yield);
      setState(1223);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 132, _ctx)) {
      case 1: {
        setState(1222);
        match(FormalParser::Multiply);
        break;
      }

      }
      setState(1225);
      dynamic_cast<YieldExpressionContext *>(_localctx)->argument_ = expression(12);

              dynamic_cast<YieldExpressionContext *>(_localctx)->type =  "YieldExpression";
          
      break;
    }

    case 15: {
      _localctx = _tracker.createInstance<AwaitExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1228);
      match(FormalParser::Await);
      setState(1229);
      dynamic_cast<AwaitExpressionContext *>(_localctx)->argument_ = expression(11);

              dynamic_cast<AwaitExpressionContext *>(_localctx)->type =  "AwaitExpression";
          
      break;
    }

    case 16: {
      _localctx = _tracker.createInstance<ImportExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1232);
      match(FormalParser::Import);
      setState(1233);
      match(FormalParser::OpenParen);
      setState(1234);
      dynamic_cast<ImportExpressionContext *>(_localctx)->source_ = expression(0);
      setState(1235);
      match(FormalParser::CloseParen);

              dynamic_cast<ImportExpressionContext *>(_localctx)->type =  "ImportExpression";
          
      break;
    }

    case 17: {
      _localctx = _tracker.createInstance<MetaPropertyContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1238);
      dynamic_cast<MetaPropertyContext *>(_localctx)->meta_ = metaPropertyIdentifier();
      setState(1239);
      match(FormalParser::Dot);
      setState(1240);
      dynamic_cast<MetaPropertyContext *>(_localctx)->property_ = identifier();

              dynamic_cast<MetaPropertyContext *>(_localctx)->type =  "MetaProperty";
          
      break;
    }

    case 18: {
      _localctx = _tracker.createInstance<ThisExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1243);
      match(FormalParser::This);

              dynamic_cast<ThisExpressionContext *>(_localctx)->type =  "ThisExpression";
          
      break;
    }

    case 19: {
      _localctx = _tracker.createInstance<IdentifierExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1245);
      identifier();

              dynamic_cast<IdentifierExpressionContext *>(_localctx)->type =  "Identifier";
          
      break;
    }

    case 20: {
      _localctx = _tracker.createInstance<SuperExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1248);
      match(FormalParser::Super);

              dynamic_cast<SuperExpressionContext *>(_localctx)->type =  "Super"; 
          
      break;
    }

    case 21: {
      _localctx = _tracker.createInstance<LiteralExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1250);
      literal();

              dynamic_cast<LiteralExpressionContext *>(_localctx)->type =  "Literal";
          
      break;
    }

    case 22: {
      _localctx = _tracker.createInstance<TemplateLiteralExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1253);
      templateLiteral();

              dynamic_cast<TemplateLiteralExpressionContext *>(_localctx)->type =  "TemplateLiteral";
          
      break;
    }

    case 23: {
      _localctx = _tracker.createInstance<ArrayExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1256);
      match(FormalParser::OpenBracket);
      setState(1258);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 133, _ctx)) {
      case 1: {
        setState(1257);
        dynamic_cast<ArrayExpressionContext *>(_localctx)->elements_ = arrayElementArrayList();
        break;
      }

      }
      setState(1260);
      match(FormalParser::CloseBracket);

              dynamic_cast<ArrayExpressionContext *>(_localctx)->type =  "ArrayExpression";
          
      break;
    }

    case 24: {
      _localctx = _tracker.createInstance<ObjectExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1262);
      match(FormalParser::OpenBrace);
      setState(1264);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx)) {
      case 1: {
        setState(1263);
        dynamic_cast<ObjectExpressionContext *>(_localctx)->properties_ = objectElementArrayList();
        break;
      }

      }
      setState(1266);
      match(FormalParser::CloseBrace);

              dynamic_cast<ObjectExpressionContext *>(_localctx)->type =  "ObjectExpression";
          
      break;
    }

    }
    _ctx->stop = _input->LT(-1);
    setState(1395);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 141, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(1393);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<ExponentiationExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1270);

          if (!(precpred(_ctx, 35))) throw FailedPredicateException(this, "precpred(_ctx, 35)");
          setState(1271);
          dynamic_cast<ExponentiationExpressionContext *>(_localctx)->operator_ = exponentiationOperator();
          setState(1272);
          dynamic_cast<ExponentiationExpressionContext *>(_localctx)->right_ = expression(36);

                            //NOTE @Add Exponentiation operator following ES2016
                            dynamic_cast<ExponentiationExpressionContext *>(_localctx)->type =  "BinaryExpression";
                        
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<MultiplicativeExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1275);

          if (!(precpred(_ctx, 34))) throw FailedPredicateException(this, "precpred(_ctx, 34)");
          setState(1276);
          dynamic_cast<MultiplicativeExpressionContext *>(_localctx)->operator_ = multiplicativeOperator();
          setState(1277);
          dynamic_cast<MultiplicativeExpressionContext *>(_localctx)->right_ = expression(35);

                            dynamic_cast<MultiplicativeExpressionContext *>(_localctx)->type =  "BinaryExpression";
                        
          break;
        }

        case 3: {
          auto newContext = _tracker.createInstance<AdditiveExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1280);

          if (!(precpred(_ctx, 33))) throw FailedPredicateException(this, "precpred(_ctx, 33)");
          setState(1281);
          dynamic_cast<AdditiveExpressionContext *>(_localctx)->operator_ = additiveOperator();
          setState(1282);
          dynamic_cast<AdditiveExpressionContext *>(_localctx)->right_ = expression(34);

                            dynamic_cast<AdditiveExpressionContext *>(_localctx)->type =  "BinaryExpression";
                        
          break;
        }

        case 4: {
          auto newContext = _tracker.createInstance<BitShiftExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1285);

          if (!(precpred(_ctx, 32))) throw FailedPredicateException(this, "precpred(_ctx, 32)");
          setState(1286);
          dynamic_cast<BitShiftExpressionContext *>(_localctx)->operator_ = bitShiftOperator();
          setState(1287);
          dynamic_cast<BitShiftExpressionContext *>(_localctx)->right_ = expression(33);

                            dynamic_cast<BitShiftExpressionContext *>(_localctx)->type =  "BinaryExpression";
                        
          break;
        }

        case 5: {
          auto newContext = _tracker.createInstance<RelationalExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1290);

          if (!(precpred(_ctx, 31))) throw FailedPredicateException(this, "precpred(_ctx, 31)");
          setState(1291);
          dynamic_cast<RelationalExpressionContext *>(_localctx)->operator_ = relationalOperator();
          setState(1292);
          dynamic_cast<RelationalExpressionContext *>(_localctx)->right_ = expression(32);

                            dynamic_cast<RelationalExpressionContext *>(_localctx)->type =  "BinaryExpression";
                        
          break;
        }

        case 6: {
          auto newContext = _tracker.createInstance<InstanceofExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1295);

          if (!(precpred(_ctx, 30))) throw FailedPredicateException(this, "precpred(_ctx, 30)");
          setState(1296);
          dynamic_cast<InstanceofExpressionContext *>(_localctx)->operator_ = instanceofOperator();
          setState(1297);
          dynamic_cast<InstanceofExpressionContext *>(_localctx)->right_ = expression(31);

                            dynamic_cast<InstanceofExpressionContext *>(_localctx)->type =  "BinaryExpression";
                        
          break;
        }

        case 7: {
          auto newContext = _tracker.createInstance<InExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1300);

          if (!(precpred(_ctx, 29))) throw FailedPredicateException(this, "precpred(_ctx, 29)");
          setState(1301);
          dynamic_cast<InExpressionContext *>(_localctx)->operator_ = inOperator();
          setState(1302);
          dynamic_cast<InExpressionContext *>(_localctx)->right_ = expression(30);

                            dynamic_cast<InExpressionContext *>(_localctx)->type =  "BinaryExpression";
                        
          break;
        }

        case 8: {
          auto newContext = _tracker.createInstance<EqualityExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1305);

          if (!(precpred(_ctx, 28))) throw FailedPredicateException(this, "precpred(_ctx, 28)");
          setState(1306);
          dynamic_cast<EqualityExpressionContext *>(_localctx)->operator_ = equalityOperator();
          setState(1307);
          dynamic_cast<EqualityExpressionContext *>(_localctx)->right_ = expression(29);

                            dynamic_cast<EqualityExpressionContext *>(_localctx)->type =  "BinaryExpression";
                        
          break;
        }

        case 9: {
          auto newContext = _tracker.createInstance<BitAndExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1310);

          if (!(precpred(_ctx, 27))) throw FailedPredicateException(this, "precpred(_ctx, 27)");
          setState(1311);
          dynamic_cast<BitAndExpressionContext *>(_localctx)->operator_ = bitAndOperator();
          setState(1312);
          dynamic_cast<BitAndExpressionContext *>(_localctx)->right_ = expression(28);

                            dynamic_cast<BitAndExpressionContext *>(_localctx)->type =  "BinaryExpression";
                    	
          break;
        }

        case 10: {
          auto newContext = _tracker.createInstance<BitXorExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1315);

          if (!(precpred(_ctx, 26))) throw FailedPredicateException(this, "precpred(_ctx, 26)");
          setState(1316);
          dynamic_cast<BitXorExpressionContext *>(_localctx)->operator_ = bitXorOperator();
          setState(1317);
          dynamic_cast<BitXorExpressionContext *>(_localctx)->right_ = expression(27);

                            dynamic_cast<BitXorExpressionContext *>(_localctx)->type =  "BinaryExpression";
                    	
          break;
        }

        case 11: {
          auto newContext = _tracker.createInstance<BitOrExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1320);

          if (!(precpred(_ctx, 25))) throw FailedPredicateException(this, "precpred(_ctx, 25)");
          setState(1321);
          dynamic_cast<BitOrExpressionContext *>(_localctx)->operator_ = bitOrOperator();
          setState(1322);
          dynamic_cast<BitOrExpressionContext *>(_localctx)->right_ = expression(26);

                            dynamic_cast<BitOrExpressionContext *>(_localctx)->type =  "BinaryExpression";
                    	
          break;
        }

        case 12: {
          auto newContext = _tracker.createInstance<LogicalExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1325);

          if (!(precpred(_ctx, 24))) throw FailedPredicateException(this, "precpred(_ctx, 24)");
          setState(1326);
          match(FormalParser::And);
          setState(1327);
          dynamic_cast<LogicalExpressionContext *>(_localctx)->right_ = expression(25);

                            dynamic_cast<LogicalExpressionContext *>(_localctx)->type =  "LogicalExpression";
                    		this->validateNullishOperatorMixedWithOtherLogicalOp(_localctx);
                    	
          break;
        }

        case 13: {
          auto newContext = _tracker.createInstance<LogicalExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1330);

          if (!(precpred(_ctx, 23))) throw FailedPredicateException(this, "precpred(_ctx, 23)");
          setState(1331);
          match(FormalParser::Or);
          setState(1332);
          dynamic_cast<LogicalExpressionContext *>(_localctx)->right_ = expression(24);

                            dynamic_cast<LogicalExpressionContext *>(_localctx)->type =  "LogicalExpression";
                    		this->validateNullishOperatorMixedWithOtherLogicalOp(_localctx);
                    		
          break;
        }

        case 14: {
          auto newContext = _tracker.createInstance<LogicalExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1335);

          if (!(precpred(_ctx, 22))) throw FailedPredicateException(this, "precpred(_ctx, 22)");
          setState(1336);
          match(FormalParser::DoubleQuestionMark);
          setState(1337);
          dynamic_cast<LogicalExpressionContext *>(_localctx)->right_ = expression(23);

                            dynamic_cast<LogicalExpressionContext *>(_localctx)->type =  "LogicalExpression";
                    		this->validateNullishOperatorMixedWithOtherLogicalOp(_localctx);
                    	
          break;
        }

        case 15: {
          auto newContext = _tracker.createInstance<ConditionalExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->test_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1340);

          if (!(precpred(_ctx, 21))) throw FailedPredicateException(this, "precpred(_ctx, 21)");
          setState(1341);
          match(FormalParser::QuestionMark);
          setState(1342);
          dynamic_cast<ConditionalExpressionContext *>(_localctx)->consequent_ = expression(0);
          setState(1343);
          match(FormalParser::Colon);
          setState(1344);
          dynamic_cast<ConditionalExpressionContext *>(_localctx)->alternate_ = expression(22);

                            dynamic_cast<ConditionalExpressionContext *>(_localctx)->type =  "ConditionalExpression";
                    	    
          break;
        }

        case 16: {
          auto newContext = _tracker.createInstance<QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->test_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1347);

          if (!(precpred(_ctx, 20))) throw FailedPredicateException(this, "precpred(_ctx, 20)");
          setState(1348);
          match(FormalParser::QuestionMarkFollowedByDecimalDirectly);
          setState(1349);
          match(FormalParser::Colon);
          setState(1350);
          dynamic_cast<QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext *>(_localctx)->alternate_ = expression(21);

                            dynamic_cast<QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext *>(_localctx)->type =  "ConditionalExpression";
                    	
          break;
        }

        case 17: {
          auto newContext = _tracker.createInstance<AssignmentExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1353);

          if (!(precpred(_ctx, 18))) throw FailedPredicateException(this, "precpred(_ctx, 18)");
          setState(1354);
          dynamic_cast<AssignmentExpressionContext *>(_localctx)->operator_ = assignmentOperator();
          setState(1355);
          dynamic_cast<AssignmentExpressionContext *>(_localctx)->right_ = expression(19);

                    		const auto assignmentExpr = static_cast<AssignmentExpressionContext*>(_localctx);
                            this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<RVALUE_IN_ASSIGNMENT_LEFT>() ,SourceCodeLocation{_localctx->getStart()->getLine(), _localctx->getStart()->getCharPositionInLine()},  [&](){
                                return nullptr == assignmentExpr->left_ || ContextIdMemberExpression != assignmentExpr->left_->getContextId() ;
                            } ); 
                            this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<OPTIONAL_CHAIN_IN_LEFTHAND_SIDE>() , [&](){
                                return nodeIsInOptionalChain(assignmentExpr->left_);
                            } );    
                            dynamic_cast<AssignmentExpressionContext *>(_localctx)->type =  "AssignmentExpression";

                        
          break;
        }

        case 18: {
          auto newContext = _tracker.createInstance<MemberExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->object_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1358);

          if (!(precpred(_ctx, 42))) throw FailedPredicateException(this, "precpred(_ctx, 42)");
          setState(1359);
          dynamic_cast<MemberExpressionContext *>(_localctx)->property_ = memberExpressionProperty();

                            //NOTE make object_ optional in memberpression following estree
                            dynamic_cast<MemberExpressionContext *>(_localctx)->type =  "MemberExpression";
                        
          break;
        }

        case 19: {
          auto newContext = _tracker.createInstance<CallExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->callee_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1362);

          if (!(precpred(_ctx, 40))) throw FailedPredicateException(this, "precpred(_ctx, 40)");
          setState(1364);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == FormalParser::OptionalChainingOperator) {
            setState(1363);
            match(FormalParser::OptionalChainingOperator);
          }
          setState(1366);
          match(FormalParser::OpenParen);
          setState(1368);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 137, _ctx)) {
          case 1: {
            setState(1367);
            dynamic_cast<CallExpressionContext *>(_localctx)->arguments_ = argumentArrayList();
            break;
          }

          }
          setState(1370);
          match(FormalParser::CloseParen);

                            dynamic_cast<CallExpressionContext *>(_localctx)->type =  "CallExpression";
                        
          break;
        }

        case 20: {
          auto newContext = _tracker.createInstance<UpdateExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->argument_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1372);

          if (!(precpred(_ctx, 38))) throw FailedPredicateException(this, "precpred(_ctx, 38)");
          setState(1373);

          if (!(this->notLineTerminator())) throw FailedPredicateException(this, "this->notLineTerminator()");
          setState(1374);
          dynamic_cast<UpdateExpressionContext *>(_localctx)->operator_ = updateOperator();

                            dynamic_cast<UpdateExpressionContext *>(_localctx)->type =  "UpdateExpression";
                        
          break;
        }

        case 21: {
          auto newContext = _tracker.createInstance<TaggedTemplateExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->tag_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1377);

          if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)");
          setState(1378);
          dynamic_cast<TaggedTemplateExpressionContext *>(_localctx)->quasi_ = templateLiteral();

                            dynamic_cast<TaggedTemplateExpressionContext *>(_localctx)->type =  "TaggedTemplateExpression";
                        
          break;
        }

        case 22: {
          auto newContext = _tracker.createInstance<TSAsExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->expression_ = previousContext;
          pushNewRecursionContext(newContext, startState, RuleExpression);
          setState(1381);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(1382);
          match(FormalParser::As);
          setState(1389);
          _errHandler->sync(this);
          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx)) {
          case 1: {
            setState(1383);
            dynamic_cast<TSAsExpressionContext *>(_localctx)->typeAnnotation_ = type_(0);
            setState(1386);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 138, _ctx)) {
            case 1: {
              setState(1384);
              match(FormalParser::OpenBracket);
              setState(1385);
              match(FormalParser::CloseBracket);
              break;
            }

            }
            break;
          }

          case 2: {
            setState(1388);
            dynamic_cast<TSAsExpressionContext *>(_localctx)->asExpression_ = expression(0);
            break;
          }

          }

                            //TODO refer to parser result from https://astexplorer.net/ @typescript-eslint/parser
                            dynamic_cast<TSAsExpressionContext *>(_localctx)->type =  "TSAsExpression";
                        
          break;
        }

        } 
      }
      setState(1397);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 141, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- IdentifierContext ------------------------------------------------------------------

FormalParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::IdentifierContext::Identifier() {
  return getToken(FormalParser::Identifier, 0);
}

FormalParser::TypeAnnotationContext* FormalParser::IdentifierContext::typeAnnotation() {
  return getRuleContext<FormalParser::TypeAnnotationContext>(0);
}

tree::TerminalNode* FormalParser::IdentifierContext::SingQuote() {
  return getToken(FormalParser::SingQuote, 0);
}

tree::TerminalNode* FormalParser::IdentifierContext::DoubleQuote() {
  return getToken(FormalParser::DoubleQuote, 0);
}

FormalParser::NumericLiteralContext* FormalParser::IdentifierContext::numericLiteral() {
  return getRuleContext<FormalParser::NumericLiteralContext>(0);
}

FormalParser::KeywordContext* FormalParser::IdentifierContext::keyword() {
  return getRuleContext<FormalParser::KeywordContext>(0);
}

FormalParser::JsPrimitiveTypeContext* FormalParser::IdentifierContext::jsPrimitiveType() {
  return getRuleContext<FormalParser::JsPrimitiveTypeContext>(0);
}

FormalParser::ExtendedPrimitiveTypeContext* FormalParser::IdentifierContext::extendedPrimitiveType() {
  return getRuleContext<FormalParser::ExtendedPrimitiveTypeContext>(0);
}

tree::TerminalNode* FormalParser::IdentifierContext::BooleanLiteral() {
  return getToken(FormalParser::BooleanLiteral, 0);
}


size_t FormalParser::IdentifierContext::getRuleIndex() const {
  return FormalParser::RuleIdentifier;
}

size_t FormalParser::IdentifierContext::getContextId() const {
  return FormalParser::ContextIdIdentifier;
}


FormalParser::IdentifierContext* FormalParser::identifier() {
  IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
  enterRule(_localctx, 178, FormalParser::RuleIdentifier);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1424);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 145, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1398);
      match(FormalParser::Identifier);
      setState(1401);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx)) {
      case 1: {
        setState(1399);

        if (!(this->canBeFollowedByTypeAnnotation())) throw FailedPredicateException(this, "this->canBeFollowedByTypeAnnotation()");
        setState(1400);
        dynamic_cast<IdentifierContext *>(_localctx)->typeAnnotation_ = typeAnnotation();
        break;
      }

      }

              dynamic_cast<IdentifierContext *>(_localctx)->type =  "Identifier";
              dynamic_cast<IdentifierContext *>(_localctx)->name =   _localctx->getText(); 
          
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1404);
      _la = _input->LA(1);
      if (!(_la == FormalParser::SingQuote

      || _la == FormalParser::DoubleQuote)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1405);
      match(FormalParser::Identifier);

      		this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<UNTERMINATED_STRING>()); 
        
          
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1407);
      match(FormalParser::Identifier);
      setState(1408);
      _la = _input->LA(1);
      if (!(_la == FormalParser::SingQuote

      || _la == FormalParser::DoubleQuote)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }

      	        this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<UNTERMINATED_STRING>()); 
          
          
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1410);
      numericLiteral();
      setState(1413);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FormalParser::Identifier: {
          setState(1411);
          match(FormalParser::Identifier);
          break;
        }

        case FormalParser::Break:
        case FormalParser::Do:
        case FormalParser::Instanceof:
        case FormalParser::Typeof:
        case FormalParser::Case:
        case FormalParser::Else:
        case FormalParser::New:
        case FormalParser::Var:
        case FormalParser::Catch:
        case FormalParser::Finally:
        case FormalParser::Return:
        case FormalParser::Void:
        case FormalParser::Continue:
        case FormalParser::For:
        case FormalParser::Switch:
        case FormalParser::While:
        case FormalParser::Debugger:
        case FormalParser::Function_:
        case FormalParser::This:
        case FormalParser::With:
        case FormalParser::Default:
        case FormalParser::If:
        case FormalParser::Throw:
        case FormalParser::Delete:
        case FormalParser::In:
        case FormalParser::Of:
        case FormalParser::Try:
        case FormalParser::From:
        case FormalParser::ReadOnly:
        case FormalParser::Async:
        case FormalParser::Class:
        case FormalParser::Enum:
        case FormalParser::Extends:
        case FormalParser::Super:
        case FormalParser::Const:
        case FormalParser::Export:
        case FormalParser::Import:
        case FormalParser::Implements:
        case FormalParser::Let:
        case FormalParser::Private:
        case FormalParser::Public:
        case FormalParser::Interface:
        case FormalParser::Package:
        case FormalParser::Protected:
        case FormalParser::Static:
        case FormalParser::Yield:
        case FormalParser::String:
        case FormalParser::TypeAlias:
        case FormalParser::Get:
        case FormalParser::Set: {
          setState(1412);
          keyword();
          break;
        }

      default:
        throw NoViableAltException(this);
      }

      		this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<IDENTIFIER_DIRECTLY_AFTER_NUMBER>()); 
          

          
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1417);

      if (!(this->isParsingProperties())) throw FailedPredicateException(this, "this->isParsingProperties()");
      setState(1422);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 144, _ctx)) {
      case 1: {
        setState(1418);
        keyword();
        break;
      }

      case 2: {
        setState(1419);
        jsPrimitiveType();
        break;
      }

      case 3: {
        setState(1420);
        extendedPrimitiveType();
        break;
      }

      case 4: {
        setState(1421);
        match(FormalParser::BooleanLiteral);
        break;
      }

      }
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MetaPropertyIdentifierContext ------------------------------------------------------------------

FormalParser::MetaPropertyIdentifierContext::MetaPropertyIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::MetaPropertyIdentifierContext::New() {
  return getToken(FormalParser::New, 0);
}

tree::TerminalNode* FormalParser::MetaPropertyIdentifierContext::Import() {
  return getToken(FormalParser::Import, 0);
}


size_t FormalParser::MetaPropertyIdentifierContext::getRuleIndex() const {
  return FormalParser::RuleMetaPropertyIdentifier;
}

size_t FormalParser::MetaPropertyIdentifierContext::getContextId() const {
  return FormalParser::ContextIdMetaPropertyIdentifier;
}


FormalParser::MetaPropertyIdentifierContext* FormalParser::metaPropertyIdentifier() {
  MetaPropertyIdentifierContext *_localctx = _tracker.createInstance<MetaPropertyIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 180, FormalParser::RuleMetaPropertyIdentifier);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1430);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FormalParser::New: {
        enterOuterAlt(_localctx, 1);
        setState(1426);
        match(FormalParser::New);

                dynamic_cast<MetaPropertyIdentifierContext *>(_localctx)->type =  "Identifier";
                dynamic_cast<MetaPropertyIdentifierContext *>(_localctx)->name =  "new";
            
        break;
      }

      case FormalParser::Import: {
        enterOuterAlt(_localctx, 2);
        setState(1428);
        match(FormalParser::Import);

                dynamic_cast<MetaPropertyIdentifierContext *>(_localctx)->type =  "Identifier";
                dynamic_cast<MetaPropertyIdentifierContext *>(_localctx)->name =  "Import";
            
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PrivateIdentifierContext ------------------------------------------------------------------

FormalParser::PrivateIdentifierContext::PrivateIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::PrivateIdentifierContext::Hashtag() {
  return getToken(FormalParser::Hashtag, 0);
}

tree::TerminalNode* FormalParser::PrivateIdentifierContext::Identifier() {
  return getToken(FormalParser::Identifier, 0);
}


size_t FormalParser::PrivateIdentifierContext::getRuleIndex() const {
  return FormalParser::RulePrivateIdentifier;
}

size_t FormalParser::PrivateIdentifierContext::getContextId() const {
  return FormalParser::ContextIdPrivateIdentifier;
}


FormalParser::PrivateIdentifierContext* FormalParser::privateIdentifier() {
  PrivateIdentifierContext *_localctx = _tracker.createInstance<PrivateIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 182, FormalParser::RulePrivateIdentifier);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1432);
    match(FormalParser::Hashtag);
    setState(1433);
    dynamic_cast<PrivateIdentifierContext *>(_localctx)->identifierToken = match(FormalParser::Identifier);

            dynamic_cast<PrivateIdentifierContext *>(_localctx)->type =  "PrivateIdentifier";
            dynamic_cast<PrivateIdentifierContext *>(_localctx)->name =   (dynamic_cast<PrivateIdentifierContext *>(_localctx)->identifierToken != nullptr ? dynamic_cast<PrivateIdentifierContext *>(_localctx)->identifierToken->getText() : "");
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MemberExpressionPropertyContext ------------------------------------------------------------------

FormalParser::MemberExpressionPropertyContext::MemberExpressionPropertyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t FormalParser::MemberExpressionPropertyContext::getRuleIndex() const {
  return FormalParser::RuleMemberExpressionProperty;
}

size_t FormalParser::MemberExpressionPropertyContext::getContextId() const {
  return FormalParser::ContextIdMemberExpressionProperty;
}

void FormalParser::MemberExpressionPropertyContext::copyFrom(MemberExpressionPropertyContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
  this->type = ctx->type;
  this->computed = ctx->computed;
  this->optional = ctx->optional;
}

//----------------- DotMemberExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::DotMemberExpressionContext::OptionalChainingOperator() {
  return getToken(FormalParser::OptionalChainingOperator, 0);
}

FormalParser::IdentifierContext* FormalParser::DotMemberExpressionContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

tree::TerminalNode* FormalParser::DotMemberExpressionContext::Dot() {
  return getToken(FormalParser::Dot, 0);
}


size_t FormalParser::DotMemberExpressionContext::getContextId() const {
  return FormalParser::ContextIdDotMemberExpression;
}

FormalParser::DotMemberExpressionContext::DotMemberExpressionContext(MemberExpressionPropertyContext *ctx) { copyFrom(ctx); }


//----------------- PrivateMemberExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::PrivateMemberExpressionContext::Dot() {
  return getToken(FormalParser::Dot, 0);
}

FormalParser::PrivateIdentifierContext* FormalParser::PrivateMemberExpressionContext::privateIdentifier() {
  return getRuleContext<FormalParser::PrivateIdentifierContext>(0);
}


size_t FormalParser::PrivateMemberExpressionContext::getContextId() const {
  return FormalParser::ContextIdPrivateMemberExpression;
}

FormalParser::PrivateMemberExpressionContext::PrivateMemberExpressionContext(MemberExpressionPropertyContext *ctx) { copyFrom(ctx); }


//----------------- BracketMemberExpressionContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::BracketMemberExpressionContext::OpenBracket() {
  return getToken(FormalParser::OpenBracket, 0);
}

tree::TerminalNode* FormalParser::BracketMemberExpressionContext::CloseBracket() {
  return getToken(FormalParser::CloseBracket, 0);
}

FormalParser::ExpressionSequenceContext* FormalParser::BracketMemberExpressionContext::expressionSequence() {
  return getRuleContext<FormalParser::ExpressionSequenceContext>(0);
}

tree::TerminalNode* FormalParser::BracketMemberExpressionContext::OptionalChainingOperator() {
  return getToken(FormalParser::OptionalChainingOperator, 0);
}


size_t FormalParser::BracketMemberExpressionContext::getContextId() const {
  return FormalParser::ContextIdBracketMemberExpression;
}

FormalParser::BracketMemberExpressionContext::BracketMemberExpressionContext(MemberExpressionPropertyContext *ctx) { copyFrom(ctx); }


FormalParser::MemberExpressionPropertyContext* FormalParser::memberExpressionProperty() {
  MemberExpressionPropertyContext *_localctx = _tracker.createInstance<MemberExpressionPropertyContext>(_ctx, getState());
  enterRule(_localctx, 184, FormalParser::RuleMemberExpressionProperty);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1459);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 147, _ctx)) {
    case 1: {
      _localctx = dynamic_cast<MemberExpressionPropertyContext *>(_tracker.createInstance<FormalParser::BracketMemberExpressionContext>(_localctx));
      enterOuterAlt(_localctx, 1);
      setState(1436);
      match(FormalParser::OpenBracket);
      setState(1437);
      dynamic_cast<BracketMemberExpressionContext *>(_localctx)->expression_ = expressionSequence();
      setState(1438);
      match(FormalParser::CloseBracket);
       
              dynamic_cast<BracketMemberExpressionContext *>(_localctx)->computed =  true; 
              dynamic_cast<BracketMemberExpressionContext *>(_localctx)->optional =  false;
              dynamic_cast<BracketMemberExpressionContext *>(_localctx)->type =  "BracketMemberExpression";
          
      break;
    }

    case 2: {
      _localctx = dynamic_cast<MemberExpressionPropertyContext *>(_tracker.createInstance<FormalParser::BracketMemberExpressionContext>(_localctx));
      enterOuterAlt(_localctx, 2);
      setState(1441);
      match(FormalParser::OptionalChainingOperator);
      setState(1442);
      match(FormalParser::OpenBracket);
      setState(1443);
      dynamic_cast<BracketMemberExpressionContext *>(_localctx)->expression_ = expressionSequence();
      setState(1444);
      match(FormalParser::CloseBracket);
       
      		dynamic_cast<BracketMemberExpressionContext *>(_localctx)->computed =  true; 
              dynamic_cast<BracketMemberExpressionContext *>(_localctx)->optional =  true;
      	        dynamic_cast<BracketMemberExpressionContext *>(_localctx)->type =  "BracketMemberExpression";
      	
      break;
    }

    case 3: {
      _localctx = dynamic_cast<MemberExpressionPropertyContext *>(_tracker.createInstance<FormalParser::DotMemberExpressionContext>(_localctx));
      enterOuterAlt(_localctx, 3);
      setState(1447);
      match(FormalParser::OptionalChainingOperator);
      setState(1448);
      identifier();
       
              dynamic_cast<DotMemberExpressionContext *>(_localctx)->computed =  false; 
              dynamic_cast<DotMemberExpressionContext *>(_localctx)->optional =  true;
              dynamic_cast<DotMemberExpressionContext *>(_localctx)->type =  "DotMemberExpression";
          
      break;
    }

    case 4: {
      _localctx = dynamic_cast<MemberExpressionPropertyContext *>(_tracker.createInstance<FormalParser::DotMemberExpressionContext>(_localctx));
      enterOuterAlt(_localctx, 4);
      setState(1451);
      match(FormalParser::Dot);
      setState(1452);
      identifier();
       
              dynamic_cast<DotMemberExpressionContext *>(_localctx)->computed =  false; 
              dynamic_cast<DotMemberExpressionContext *>(_localctx)->optional =  false;
              dynamic_cast<DotMemberExpressionContext *>(_localctx)->type =  "DotMemberExpression"; 
          
      break;
    }

    case 5: {
      _localctx = dynamic_cast<MemberExpressionPropertyContext *>(_tracker.createInstance<FormalParser::PrivateMemberExpressionContext>(_localctx));
      enterOuterAlt(_localctx, 5);
      setState(1455);
      match(FormalParser::Dot);
      setState(1456);
      privateIdentifier();
       
              dynamic_cast<PrivateMemberExpressionContext *>(_localctx)->computed =  false; 
              dynamic_cast<PrivateMemberExpressionContext *>(_localctx)->optional =  false;
              dynamic_cast<PrivateMemberExpressionContext *>(_localctx)->type =  "PrivateMemberExpression"; 
          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArrowFunctionParametersContext ------------------------------------------------------------------

FormalParser::ArrowFunctionParametersContext::ArrowFunctionParametersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ArrowFunctionParametersContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::ArrowFunctionParametersContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::ParameterListContext* FormalParser::ArrowFunctionParametersContext::parameterList() {
  return getRuleContext<FormalParser::ParameterListContext>(0);
}

FormalParser::IdentifierContext* FormalParser::ArrowFunctionParametersContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}


size_t FormalParser::ArrowFunctionParametersContext::getRuleIndex() const {
  return FormalParser::RuleArrowFunctionParameters;
}

size_t FormalParser::ArrowFunctionParametersContext::getContextId() const {
  return FormalParser::ContextIdArrowFunctionParameters;
}


FormalParser::ArrowFunctionParametersContext* FormalParser::arrowFunctionParameters() {
  ArrowFunctionParametersContext *_localctx = _tracker.createInstance<ArrowFunctionParametersContext>(_ctx, getState());
  enterRule(_localctx, 186, FormalParser::RuleArrowFunctionParameters);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1467);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 149, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1461);
      match(FormalParser::OpenParen);
      setState(1463);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 148, _ctx)) {
      case 1: {
        setState(1462);
        parameterList();
        break;
      }

      }
      setState(1465);
      match(FormalParser::CloseParen);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1466);
      identifier();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArrowFunctionBodyContext ------------------------------------------------------------------

FormalParser::ArrowFunctionBodyContext::ArrowFunctionBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::BraceBlockContext* FormalParser::ArrowFunctionBodyContext::braceBlock() {
  return getRuleContext<FormalParser::BraceBlockContext>(0);
}

FormalParser::ExpressionContext* FormalParser::ArrowFunctionBodyContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::ArrowFunctionBodyContext::getRuleIndex() const {
  return FormalParser::RuleArrowFunctionBody;
}

size_t FormalParser::ArrowFunctionBodyContext::getContextId() const {
  return FormalParser::ContextIdArrowFunctionBody;
}


FormalParser::ArrowFunctionBodyContext* FormalParser::arrowFunctionBody() {
  ArrowFunctionBodyContext *_localctx = _tracker.createInstance<ArrowFunctionBodyContext>(_ctx, getState());
  enterRule(_localctx, 188, FormalParser::RuleArrowFunctionBody);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1471);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 150, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1469);
      braceBlock();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1470);
      expression(0);
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignmentOperatorContext ------------------------------------------------------------------

FormalParser::AssignmentOperatorContext::AssignmentOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::Assign() {
  return getToken(FormalParser::Assign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::MultiplyAssign() {
  return getToken(FormalParser::MultiplyAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::DivideAssign() {
  return getToken(FormalParser::DivideAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::ModulusAssign() {
  return getToken(FormalParser::ModulusAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::ExponentiationAssign() {
  return getToken(FormalParser::ExponentiationAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::PlusAssign() {
  return getToken(FormalParser::PlusAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::MinusAssign() {
  return getToken(FormalParser::MinusAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::LeftShiftArithmeticAssign() {
  return getToken(FormalParser::LeftShiftArithmeticAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::RightShiftArithmeticAssign() {
  return getToken(FormalParser::RightShiftArithmeticAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::RightShiftLogicalAssign() {
  return getToken(FormalParser::RightShiftLogicalAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::BitAndAssign() {
  return getToken(FormalParser::BitAndAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::BitXorAssign() {
  return getToken(FormalParser::BitXorAssign, 0);
}

tree::TerminalNode* FormalParser::AssignmentOperatorContext::BitOrAssign() {
  return getToken(FormalParser::BitOrAssign, 0);
}


size_t FormalParser::AssignmentOperatorContext::getRuleIndex() const {
  return FormalParser::RuleAssignmentOperator;
}

size_t FormalParser::AssignmentOperatorContext::getContextId() const {
  return FormalParser::ContextIdAssignmentOperator;
}


FormalParser::AssignmentOperatorContext* FormalParser::assignmentOperator() {
  AssignmentOperatorContext *_localctx = _tracker.createInstance<AssignmentOperatorContext>(_ctx, getState());
  enterRule(_localctx, 190, FormalParser::RuleAssignmentOperator);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1473);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << FormalParser::Assign)
      | (1ULL << FormalParser::MultiplyAssign)
      | (1ULL << FormalParser::DivideAssign)
      | (1ULL << FormalParser::ModulusAssign)
      | (1ULL << FormalParser::ExponentiationAssign)
      | (1ULL << FormalParser::PlusAssign)
      | (1ULL << FormalParser::MinusAssign)
      | (1ULL << FormalParser::LeftShiftArithmeticAssign)
      | (1ULL << FormalParser::RightShiftArithmeticAssign)
      | (1ULL << FormalParser::RightShiftLogicalAssign)
      | (1ULL << FormalParser::BitAndAssign)
      | (1ULL << FormalParser::BitXorAssign)
      | (1ULL << FormalParser::BitOrAssign))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NumericLiteralContext ------------------------------------------------------------------

FormalParser::NumericLiteralContext::NumericLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::NumericLiteralContext::DecimalLiteral() {
  return getToken(FormalParser::DecimalLiteral, 0);
}

tree::TerminalNode* FormalParser::NumericLiteralContext::HexIntegerLiteral() {
  return getToken(FormalParser::HexIntegerLiteral, 0);
}

tree::TerminalNode* FormalParser::NumericLiteralContext::OctalIntegerLiteral() {
  return getToken(FormalParser::OctalIntegerLiteral, 0);
}

tree::TerminalNode* FormalParser::NumericLiteralContext::OctalIntegerLiteral2() {
  return getToken(FormalParser::OctalIntegerLiteral2, 0);
}

tree::TerminalNode* FormalParser::NumericLiteralContext::BinaryIntegerLiteral() {
  return getToken(FormalParser::BinaryIntegerLiteral, 0);
}


size_t FormalParser::NumericLiteralContext::getRuleIndex() const {
  return FormalParser::RuleNumericLiteral;
}

size_t FormalParser::NumericLiteralContext::getContextId() const {
  return FormalParser::ContextIdNumericLiteral;
}


FormalParser::NumericLiteralContext* FormalParser::numericLiteral() {
  NumericLiteralContext *_localctx = _tracker.createInstance<NumericLiteralContext>(_ctx, getState());
  enterRule(_localctx, 192, FormalParser::RuleNumericLiteral);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1475);
    _la = _input->LA(1);
    if (!(((((_la - 62) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 62)) & ((1ULL << (FormalParser::DecimalLiteral - 62))
      | (1ULL << (FormalParser::HexIntegerLiteral - 62))
      | (1ULL << (FormalParser::OctalIntegerLiteral - 62))
      | (1ULL << (FormalParser::OctalIntegerLiteral2 - 62))
      | (1ULL << (FormalParser::BinaryIntegerLiteral - 62)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LiteralContext ------------------------------------------------------------------

FormalParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::LiteralContext::NullLiteral() {
  return getToken(FormalParser::NullLiteral, 0);
}

tree::TerminalNode* FormalParser::LiteralContext::BooleanLiteral() {
  return getToken(FormalParser::BooleanLiteral, 0);
}

tree::TerminalNode* FormalParser::LiteralContext::StringLiteral() {
  return getToken(FormalParser::StringLiteral, 0);
}

tree::TerminalNode* FormalParser::LiteralContext::RegularExpressionLiteral() {
  return getToken(FormalParser::RegularExpressionLiteral, 0);
}

FormalParser::NumericLiteralContext* FormalParser::LiteralContext::numericLiteral() {
  return getRuleContext<FormalParser::NumericLiteralContext>(0);
}

tree::TerminalNode* FormalParser::LiteralContext::BigInt() {
  return getToken(FormalParser::BigInt, 0);
}


size_t FormalParser::LiteralContext::getRuleIndex() const {
  return FormalParser::RuleLiteral;
}

size_t FormalParser::LiteralContext::getContextId() const {
  return FormalParser::ContextIdLiteral;
}


FormalParser::LiteralContext* FormalParser::literal() {
  LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
  enterRule(_localctx, 194, FormalParser::RuleLiteral);

      dynamic_cast<LiteralContext *>(_localctx)->type =  "Literal";


  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1484);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FormalParser::NullLiteral: {
        enterOuterAlt(_localctx, 1);
        setState(1477);
        match(FormalParser::NullLiteral);
        break;
      }

      case FormalParser::BooleanLiteral: {
        enterOuterAlt(_localctx, 2);
        setState(1478);
        match(FormalParser::BooleanLiteral);
        break;
      }

      case FormalParser::StringLiteral: {
        enterOuterAlt(_localctx, 3);
        setState(1479);
        match(FormalParser::StringLiteral);
        break;
      }

      case FormalParser::RegularExpressionLiteral: {
        enterOuterAlt(_localctx, 4);
        setState(1480);
        match(FormalParser::RegularExpressionLiteral);

        		this->checkIsValidRegexFlag(_localctx->getText());
        	
        break;
      }

      case FormalParser::DecimalLiteral:
      case FormalParser::HexIntegerLiteral:
      case FormalParser::OctalIntegerLiteral:
      case FormalParser::OctalIntegerLiteral2:
      case FormalParser::BinaryIntegerLiteral: {
        enterOuterAlt(_localctx, 5);
        setState(1482);
        numericLiteral();
        break;
      }

      case FormalParser::BigInt: {
        enterOuterAlt(_localctx, 6);
        setState(1483);
        match(FormalParser::BigInt);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateLiteralContext ------------------------------------------------------------------

FormalParser::TemplateLiteralContext::TemplateLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FormalParser::TemplateLiteralContext::BackTick() {
  return getTokens(FormalParser::BackTick);
}

tree::TerminalNode* FormalParser::TemplateLiteralContext::BackTick(size_t i) {
  return getToken(FormalParser::BackTick, i);
}

std::vector<FormalParser::TemplateStringAtomContext *> FormalParser::TemplateLiteralContext::templateStringAtom() {
  return getRuleContexts<FormalParser::TemplateStringAtomContext>();
}

FormalParser::TemplateStringAtomContext* FormalParser::TemplateLiteralContext::templateStringAtom(size_t i) {
  return getRuleContext<FormalParser::TemplateStringAtomContext>(i);
}


size_t FormalParser::TemplateLiteralContext::getRuleIndex() const {
  return FormalParser::RuleTemplateLiteral;
}

size_t FormalParser::TemplateLiteralContext::getContextId() const {
  return FormalParser::ContextIdTemplateLiteral;
}


FormalParser::TemplateLiteralContext* FormalParser::templateLiteral() {
  TemplateLiteralContext *_localctx = _tracker.createInstance<TemplateLiteralContext>(_ctx, getState());
  enterRule(_localctx, 196, FormalParser::RuleTemplateLiteral);

      dynamic_cast<TemplateLiteralContext *>(_localctx)->type =  "TemplateLiteral";

  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1486);
    match(FormalParser::BackTick);
    setState(1490);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::TemplateStringStartExpression

    || _la == FormalParser::TemplateStringAtom) {
      setState(1487);
      dynamic_cast<TemplateLiteralContext *>(_localctx)->templateStringAtom_ = templateStringAtom();
      setState(1492);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1493);
    match(FormalParser::BackTick);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateStringAtomContext ------------------------------------------------------------------

FormalParser::TemplateStringAtomContext::TemplateStringAtomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t FormalParser::TemplateStringAtomContext::getRuleIndex() const {
  return FormalParser::RuleTemplateStringAtom;
}

size_t FormalParser::TemplateStringAtomContext::getContextId() const {
  return FormalParser::ContextIdTemplateStringAtom;
}

void FormalParser::TemplateStringAtomContext::copyFrom(TemplateStringAtomContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- AtomTemplateStringContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::AtomTemplateStringContext::TemplateStringAtom() {
  return getToken(FormalParser::TemplateStringAtom, 0);
}


size_t FormalParser::AtomTemplateStringContext::getContextId() const {
  return FormalParser::ContextIdAtomTemplateString;
}

FormalParser::AtomTemplateStringContext::AtomTemplateStringContext(TemplateStringAtomContext *ctx) { copyFrom(ctx); }


//----------------- BraceTemplateStringContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::BraceTemplateStringContext::TemplateStringStartExpression() {
  return getToken(FormalParser::TemplateStringStartExpression, 0);
}

tree::TerminalNode* FormalParser::BraceTemplateStringContext::TemplateCloseBrace() {
  return getToken(FormalParser::TemplateCloseBrace, 0);
}

FormalParser::ExpressionContext* FormalParser::BraceTemplateStringContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::BraceTemplateStringContext::getContextId() const {
  return FormalParser::ContextIdBraceTemplateString;
}

FormalParser::BraceTemplateStringContext::BraceTemplateStringContext(TemplateStringAtomContext *ctx) { copyFrom(ctx); }


FormalParser::TemplateStringAtomContext* FormalParser::templateStringAtom() {
  TemplateStringAtomContext *_localctx = _tracker.createInstance<TemplateStringAtomContext>(_ctx, getState());
  enterRule(_localctx, 198, FormalParser::RuleTemplateStringAtom);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1500);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FormalParser::TemplateStringAtom: {
        _localctx = dynamic_cast<TemplateStringAtomContext *>(_tracker.createInstance<FormalParser::AtomTemplateStringContext>(_localctx));
        enterOuterAlt(_localctx, 1);
        setState(1495);
        match(FormalParser::TemplateStringAtom);
        break;
      }

      case FormalParser::TemplateStringStartExpression: {
        _localctx = dynamic_cast<TemplateStringAtomContext *>(_tracker.createInstance<FormalParser::BraceTemplateStringContext>(_localctx));
        enterOuterAlt(_localctx, 2);
        setState(1496);
        match(FormalParser::TemplateStringStartExpression);
        setState(1497);
        dynamic_cast<BraceTemplateStringContext *>(_localctx)->expression_ = expression(0);
        setState(1498);
        match(FormalParser::TemplateCloseBrace);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeywordContext ------------------------------------------------------------------

FormalParser::KeywordContext::KeywordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::KeywordContext::Break() {
  return getToken(FormalParser::Break, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Do() {
  return getToken(FormalParser::Do, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Instanceof() {
  return getToken(FormalParser::Instanceof, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Typeof() {
  return getToken(FormalParser::Typeof, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Case() {
  return getToken(FormalParser::Case, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Else() {
  return getToken(FormalParser::Else, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::New() {
  return getToken(FormalParser::New, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Var() {
  return getToken(FormalParser::Var, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Catch() {
  return getToken(FormalParser::Catch, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Finally() {
  return getToken(FormalParser::Finally, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Return() {
  return getToken(FormalParser::Return, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Void() {
  return getToken(FormalParser::Void, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Continue() {
  return getToken(FormalParser::Continue, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::For() {
  return getToken(FormalParser::For, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Switch() {
  return getToken(FormalParser::Switch, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::While() {
  return getToken(FormalParser::While, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Debugger() {
  return getToken(FormalParser::Debugger, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Function_() {
  return getToken(FormalParser::Function_, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::This() {
  return getToken(FormalParser::This, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::With() {
  return getToken(FormalParser::With, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Default() {
  return getToken(FormalParser::Default, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::If() {
  return getToken(FormalParser::If, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Throw() {
  return getToken(FormalParser::Throw, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Delete() {
  return getToken(FormalParser::Delete, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::In() {
  return getToken(FormalParser::In, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Of() {
  return getToken(FormalParser::Of, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Try() {
  return getToken(FormalParser::Try, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::ReadOnly() {
  return getToken(FormalParser::ReadOnly, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Async() {
  return getToken(FormalParser::Async, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::From() {
  return getToken(FormalParser::From, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Class() {
  return getToken(FormalParser::Class, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Enum() {
  return getToken(FormalParser::Enum, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Extends() {
  return getToken(FormalParser::Extends, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Super() {
  return getToken(FormalParser::Super, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Const() {
  return getToken(FormalParser::Const, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Export() {
  return getToken(FormalParser::Export, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Import() {
  return getToken(FormalParser::Import, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Implements() {
  return getToken(FormalParser::Implements, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Let() {
  return getToken(FormalParser::Let, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Private() {
  return getToken(FormalParser::Private, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Public() {
  return getToken(FormalParser::Public, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Interface() {
  return getToken(FormalParser::Interface, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Package() {
  return getToken(FormalParser::Package, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Protected() {
  return getToken(FormalParser::Protected, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Static() {
  return getToken(FormalParser::Static, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Yield() {
  return getToken(FormalParser::Yield, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Get() {
  return getToken(FormalParser::Get, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::Set() {
  return getToken(FormalParser::Set, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::TypeAlias() {
  return getToken(FormalParser::TypeAlias, 0);
}

tree::TerminalNode* FormalParser::KeywordContext::String() {
  return getToken(FormalParser::String, 0);
}


size_t FormalParser::KeywordContext::getRuleIndex() const {
  return FormalParser::RuleKeyword;
}

size_t FormalParser::KeywordContext::getContextId() const {
  return FormalParser::ContextIdKeyword;
}


FormalParser::KeywordContext* FormalParser::keyword() {
  KeywordContext *_localctx = _tracker.createInstance<KeywordContext>(_ctx, getState());
  enterRule(_localctx, 200, FormalParser::RuleKeyword);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1502);
    _la = _input->LA(1);
    if (!(((((_la - 68) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 68)) & ((1ULL << (FormalParser::Break - 68))
      | (1ULL << (FormalParser::Do - 68))
      | (1ULL << (FormalParser::Instanceof - 68))
      | (1ULL << (FormalParser::Typeof - 68))
      | (1ULL << (FormalParser::Case - 68))
      | (1ULL << (FormalParser::Else - 68))
      | (1ULL << (FormalParser::New - 68))
      | (1ULL << (FormalParser::Var - 68))
      | (1ULL << (FormalParser::Catch - 68))
      | (1ULL << (FormalParser::Finally - 68))
      | (1ULL << (FormalParser::Return - 68))
      | (1ULL << (FormalParser::Void - 68))
      | (1ULL << (FormalParser::Continue - 68))
      | (1ULL << (FormalParser::For - 68))
      | (1ULL << (FormalParser::Switch - 68))
      | (1ULL << (FormalParser::While - 68))
      | (1ULL << (FormalParser::Debugger - 68))
      | (1ULL << (FormalParser::Function_ - 68))
      | (1ULL << (FormalParser::This - 68))
      | (1ULL << (FormalParser::With - 68))
      | (1ULL << (FormalParser::Default - 68))
      | (1ULL << (FormalParser::If - 68))
      | (1ULL << (FormalParser::Throw - 68))
      | (1ULL << (FormalParser::Delete - 68))
      | (1ULL << (FormalParser::In - 68))
      | (1ULL << (FormalParser::Of - 68))
      | (1ULL << (FormalParser::Try - 68))
      | (1ULL << (FormalParser::From - 68))
      | (1ULL << (FormalParser::ReadOnly - 68))
      | (1ULL << (FormalParser::Async - 68))
      | (1ULL << (FormalParser::Class - 68))
      | (1ULL << (FormalParser::Enum - 68))
      | (1ULL << (FormalParser::Extends - 68))
      | (1ULL << (FormalParser::Super - 68))
      | (1ULL << (FormalParser::Const - 68))
      | (1ULL << (FormalParser::Export - 68))
      | (1ULL << (FormalParser::Import - 68))
      | (1ULL << (FormalParser::Implements - 68))
      | (1ULL << (FormalParser::Let - 68))
      | (1ULL << (FormalParser::Private - 68))
      | (1ULL << (FormalParser::Public - 68))
      | (1ULL << (FormalParser::Interface - 68))
      | (1ULL << (FormalParser::Package - 68))
      | (1ULL << (FormalParser::Protected - 68))
      | (1ULL << (FormalParser::Static - 68))
      | (1ULL << (FormalParser::Yield - 68))
      | (1ULL << (FormalParser::String - 68)))) != 0) || ((((_la - 140) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 140)) & ((1ULL << (FormalParser::TypeAlias - 140))
      | (1ULL << (FormalParser::Get - 140))
      | (1ULL << (FormalParser::Set - 140)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GetterContext ------------------------------------------------------------------

FormalParser::GetterContext::GetterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::GetterContext::Get() {
  return getToken(FormalParser::Get, 0);
}

FormalParser::PropertyNameContext* FormalParser::GetterContext::propertyName() {
  return getRuleContext<FormalParser::PropertyNameContext>(0);
}


size_t FormalParser::GetterContext::getRuleIndex() const {
  return FormalParser::RuleGetter;
}

size_t FormalParser::GetterContext::getContextId() const {
  return FormalParser::ContextIdGetter;
}


FormalParser::GetterContext* FormalParser::getter() {
  GetterContext *_localctx = _tracker.createInstance<GetterContext>(_ctx, getState());
  enterRule(_localctx, 202, FormalParser::RuleGetter);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1504);
    match(FormalParser::Get);
    setState(1505);
    dynamic_cast<GetterContext *>(_localctx)->propertyName_ = propertyName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetterContext ------------------------------------------------------------------

FormalParser::SetterContext::SetterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::SetterContext::Set() {
  return getToken(FormalParser::Set, 0);
}

FormalParser::PropertyNameContext* FormalParser::SetterContext::propertyName() {
  return getRuleContext<FormalParser::PropertyNameContext>(0);
}


size_t FormalParser::SetterContext::getRuleIndex() const {
  return FormalParser::RuleSetter;
}

size_t FormalParser::SetterContext::getContextId() const {
  return FormalParser::ContextIdSetter;
}


FormalParser::SetterContext* FormalParser::setter() {
  SetterContext *_localctx = _tracker.createInstance<SetterContext>(_ctx, getState());
  enterRule(_localctx, 204, FormalParser::RuleSetter);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1507);
    match(FormalParser::Set);
    setState(1508);
    dynamic_cast<SetterContext *>(_localctx)->propertyName_ = propertyName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EosContext ------------------------------------------------------------------

FormalParser::EosContext::EosContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::EosContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}

tree::TerminalNode* FormalParser::EosContext::EOF() {
  return getToken(FormalParser::EOF, 0);
}


size_t FormalParser::EosContext::getRuleIndex() const {
  return FormalParser::RuleEos;
}

size_t FormalParser::EosContext::getContextId() const {
  return FormalParser::ContextIdEos;
}


FormalParser::EosContext* FormalParser::eos() {
  EosContext *_localctx = _tracker.createInstance<EosContext>(_ctx, getState());
  enterRule(_localctx, 206, FormalParser::RuleEos);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1514);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1510);
      match(FormalParser::SemiColon);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1511);
      match(FormalParser::EOF);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1512);

      if (!(this->lineTerminatorAhead())) throw FailedPredicateException(this, "this->lineTerminatorAhead()");
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1513);

      if (!(this->closeBrace())) throw FailedPredicateException(this, "this->closeBrace()");
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignableContext ------------------------------------------------------------------

FormalParser::AssignableContext::AssignableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::PatternContext* FormalParser::AssignableContext::pattern() {
  return getRuleContext<FormalParser::PatternContext>(0);
}

FormalParser::ExpressionContext* FormalParser::AssignableContext::expression() {
  return getRuleContext<FormalParser::ExpressionContext>(0);
}


size_t FormalParser::AssignableContext::getRuleIndex() const {
  return FormalParser::RuleAssignable;
}

size_t FormalParser::AssignableContext::getContextId() const {
  return FormalParser::ContextIdAssignable;
}


FormalParser::AssignableContext* FormalParser::assignable() {
  AssignableContext *_localctx = _tracker.createInstance<AssignableContext>(_ctx, getState());
  enterRule(_localctx, 208, FormalParser::RuleAssignable);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1520);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 155, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1516);
      pattern();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1517);
      expression(0);
       
              auto expressionPtr =  expression(0);
              this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<RVALUE_IN_ASSIGNMENT_LEFT>() , [&](){
                  return nullptr == expressionPtr  ||  ContextIdMemberExpression != expressionPtr->getContextId();
              } );
              this->throwSyntaxError(SyntaxErrorFormmatter::formatErrorMessage<OPTIONAL_CHAIN_IN_LEFTHAND_SIDE>() , [&](){
                  return nodeIsInOptionalChain(expressionPtr);
              } );  
          
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeAnnotationContext ------------------------------------------------------------------

FormalParser::TypeAnnotationContext::TypeAnnotationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::TypeAnnotationContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

FormalParser::Type_Context* FormalParser::TypeAnnotationContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}


size_t FormalParser::TypeAnnotationContext::getRuleIndex() const {
  return FormalParser::RuleTypeAnnotation;
}

size_t FormalParser::TypeAnnotationContext::getContextId() const {
  return FormalParser::ContextIdTypeAnnotation;
}


FormalParser::TypeAnnotationContext* FormalParser::typeAnnotation() {
  TypeAnnotationContext *_localctx = _tracker.createInstance<TypeAnnotationContext>(_ctx, getState());
  enterRule(_localctx, 210, FormalParser::RuleTypeAnnotation);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1522);
    match(FormalParser::Colon);
    setState(1523);
    dynamic_cast<TypeAnnotationContext *>(_localctx)->typeAnnotation_ = type_(0);

             dynamic_cast<TypeAnnotationContext *>(_localctx)->type =  "TypeAnnotation";
        
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QualifiedNameContext ------------------------------------------------------------------

FormalParser::QualifiedNameContext::QualifiedNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::IdentifierContext *> FormalParser::QualifiedNameContext::identifier() {
  return getRuleContexts<FormalParser::IdentifierContext>();
}

FormalParser::IdentifierContext* FormalParser::QualifiedNameContext::identifier(size_t i) {
  return getRuleContext<FormalParser::IdentifierContext>(i);
}

std::vector<tree::TerminalNode *> FormalParser::QualifiedNameContext::Dot() {
  return getTokens(FormalParser::Dot);
}

tree::TerminalNode* FormalParser::QualifiedNameContext::Dot(size_t i) {
  return getToken(FormalParser::Dot, i);
}

tree::TerminalNode* FormalParser::QualifiedNameContext::This() {
  return getToken(FormalParser::This, 0);
}


size_t FormalParser::QualifiedNameContext::getRuleIndex() const {
  return FormalParser::RuleQualifiedName;
}

size_t FormalParser::QualifiedNameContext::getContextId() const {
  return FormalParser::ContextIdQualifiedName;
}


FormalParser::QualifiedNameContext* FormalParser::qualifiedName() {
  QualifiedNameContext *_localctx = _tracker.createInstance<QualifiedNameContext>(_ctx, getState());
  enterRule(_localctx, 212, FormalParser::RuleQualifiedName);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    size_t alt;
    setState(1542);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1529); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1526);
                identifier();
                setState(1527);
                match(FormalParser::Dot);
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1531); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      setState(1533);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1535);
      match(FormalParser::This);
      setState(1538); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1536);
                match(FormalParser::Dot);
                setState(1537);
                identifier();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1540); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 157, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    }
   _ctx->stop = _input->LT(-1);

    		dynamic_cast<QualifiedNameContext *>(_localctx)->type =  "QualifiedName";
    	
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeNameContext ------------------------------------------------------------------

FormalParser::TypeNameContext::TypeNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::IdentifierContext* FormalParser::TypeNameContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::QualifiedNameContext* FormalParser::TypeNameContext::qualifiedName() {
  return getRuleContext<FormalParser::QualifiedNameContext>(0);
}


size_t FormalParser::TypeNameContext::getRuleIndex() const {
  return FormalParser::RuleTypeName;
}

size_t FormalParser::TypeNameContext::getContextId() const {
  return FormalParser::ContextIdTypeName;
}


FormalParser::TypeNameContext* FormalParser::typeName() {
  TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, getState());
  enterRule(_localctx, 214, FormalParser::RuleTypeName);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1546);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 159, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1544);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1545);
      qualifiedName();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JsPrimitiveTypeContext ------------------------------------------------------------------

FormalParser::JsPrimitiveTypeContext::JsPrimitiveTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::JsPrimitiveTypeContext::Boolean() {
  return getToken(FormalParser::Boolean, 0);
}

tree::TerminalNode* FormalParser::JsPrimitiveTypeContext::Number() {
  return getToken(FormalParser::Number, 0);
}

tree::TerminalNode* FormalParser::JsPrimitiveTypeContext::String() {
  return getToken(FormalParser::String, 0);
}

tree::TerminalNode* FormalParser::JsPrimitiveTypeContext::NullLiteral() {
  return getToken(FormalParser::NullLiteral, 0);
}

tree::TerminalNode* FormalParser::JsPrimitiveTypeContext::Symbol() {
  return getToken(FormalParser::Symbol, 0);
}

tree::TerminalNode* FormalParser::JsPrimitiveTypeContext::Undefined() {
  return getToken(FormalParser::Undefined, 0);
}

tree::TerminalNode* FormalParser::JsPrimitiveTypeContext::BigIntAnnotation() {
  return getToken(FormalParser::BigIntAnnotation, 0);
}


size_t FormalParser::JsPrimitiveTypeContext::getRuleIndex() const {
  return FormalParser::RuleJsPrimitiveType;
}

size_t FormalParser::JsPrimitiveTypeContext::getContextId() const {
  return FormalParser::ContextIdJsPrimitiveType;
}


FormalParser::JsPrimitiveTypeContext* FormalParser::jsPrimitiveType() {
  JsPrimitiveTypeContext *_localctx = _tracker.createInstance<JsPrimitiveTypeContext>(_ctx, getState());
  enterRule(_localctx, 216, FormalParser::RuleJsPrimitiveType);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1556);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 160, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1548);
      match(FormalParser::Boolean);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1549);
      match(FormalParser::Number);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1550);
      match(FormalParser::String);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1551);
      match(FormalParser::NullLiteral);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1552);
      match(FormalParser::Symbol);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1553);

      if (!(this->allowUndefinedInType())) throw FailedPredicateException(this, "this->allowUndefinedInType()");
      setState(1554);
      match(FormalParser::Undefined);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1555);
      match(FormalParser::BigIntAnnotation);
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExtendedPrimitiveTypeContext ------------------------------------------------------------------

FormalParser::ExtendedPrimitiveTypeContext::ExtendedPrimitiveTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Int8() {
  return getToken(FormalParser::Int8, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Int16() {
  return getToken(FormalParser::Int16, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Int32() {
  return getToken(FormalParser::Int32, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Int64() {
  return getToken(FormalParser::Int64, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Uint8() {
  return getToken(FormalParser::Uint8, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Uint16() {
  return getToken(FormalParser::Uint16, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Uint32() {
  return getToken(FormalParser::Uint32, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Uint64() {
  return getToken(FormalParser::Uint64, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Float() {
  return getToken(FormalParser::Float, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Double() {
  return getToken(FormalParser::Double, 0);
}

tree::TerminalNode* FormalParser::ExtendedPrimitiveTypeContext::Decimal() {
  return getToken(FormalParser::Decimal, 0);
}


size_t FormalParser::ExtendedPrimitiveTypeContext::getRuleIndex() const {
  return FormalParser::RuleExtendedPrimitiveType;
}

size_t FormalParser::ExtendedPrimitiveTypeContext::getContextId() const {
  return FormalParser::ContextIdExtendedPrimitiveType;
}


FormalParser::ExtendedPrimitiveTypeContext* FormalParser::extendedPrimitiveType() {
  ExtendedPrimitiveTypeContext *_localctx = _tracker.createInstance<ExtendedPrimitiveTypeContext>(_ctx, getState());
  enterRule(_localctx, 218, FormalParser::RuleExtendedPrimitiveType);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1558);
    _la = _input->LA(1);
    if (!(((((_la - 123) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 123)) & ((1ULL << (FormalParser::Int8 - 123))
      | (1ULL << (FormalParser::Int16 - 123))
      | (1ULL << (FormalParser::Int32 - 123))
      | (1ULL << (FormalParser::Int64 - 123))
      | (1ULL << (FormalParser::Uint8 - 123))
      | (1ULL << (FormalParser::Uint16 - 123))
      | (1ULL << (FormalParser::Uint32 - 123))
      | (1ULL << (FormalParser::Uint64 - 123))
      | (1ULL << (FormalParser::Float - 123))
      | (1ULL << (FormalParser::Double - 123))
      | (1ULL << (FormalParser::Decimal - 123)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeListContext ------------------------------------------------------------------

FormalParser::TypeListContext::TypeListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::Type_Context *> FormalParser::TypeListContext::type_() {
  return getRuleContexts<FormalParser::Type_Context>();
}

FormalParser::Type_Context* FormalParser::TypeListContext::type_(size_t i) {
  return getRuleContext<FormalParser::Type_Context>(i);
}

std::vector<tree::TerminalNode *> FormalParser::TypeListContext::Comma() {
  return getTokens(FormalParser::Comma);
}

tree::TerminalNode* FormalParser::TypeListContext::Comma(size_t i) {
  return getToken(FormalParser::Comma, i);
}


size_t FormalParser::TypeListContext::getRuleIndex() const {
  return FormalParser::RuleTypeList;
}

size_t FormalParser::TypeListContext::getContextId() const {
  return FormalParser::ContextIdTypeList;
}


FormalParser::TypeListContext* FormalParser::typeList() {
  TypeListContext *_localctx = _tracker.createInstance<TypeListContext>(_ctx, getState());
  enterRule(_localctx, 220, FormalParser::RuleTypeList);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1560);
    type_(0);
    setState(1565);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::Comma) {
      setState(1561);
      match(FormalParser::Comma);
      setState(1562);
      type_(0);
      setState(1567);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }

    			dynamic_cast<TypeListContext *>(_localctx)->isArrayList =  true;
    	
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AnonymousObjectPropertyListSeparatorContext ------------------------------------------------------------------

FormalParser::AnonymousObjectPropertyListSeparatorContext::AnonymousObjectPropertyListSeparatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::AnonymousObjectPropertyListSeparatorContext::Comma() {
  return getToken(FormalParser::Comma, 0);
}

tree::TerminalNode* FormalParser::AnonymousObjectPropertyListSeparatorContext::SemiColon() {
  return getToken(FormalParser::SemiColon, 0);
}


size_t FormalParser::AnonymousObjectPropertyListSeparatorContext::getRuleIndex() const {
  return FormalParser::RuleAnonymousObjectPropertyListSeparator;
}

size_t FormalParser::AnonymousObjectPropertyListSeparatorContext::getContextId() const {
  return FormalParser::ContextIdAnonymousObjectPropertyListSeparator;
}


FormalParser::AnonymousObjectPropertyListSeparatorContext* FormalParser::anonymousObjectPropertyListSeparator() {
  AnonymousObjectPropertyListSeparatorContext *_localctx = _tracker.createInstance<AnonymousObjectPropertyListSeparatorContext>(_ctx, getState());
  enterRule(_localctx, 222, FormalParser::RuleAnonymousObjectPropertyListSeparator);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1570);
    _la = _input->LA(1);
    if (!(_la == FormalParser::SemiColon

    || _la == FormalParser::Comma)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AnonymousObjectPropertyListContext ------------------------------------------------------------------

FormalParser::AnonymousObjectPropertyListContext::AnonymousObjectPropertyListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FormalParser::ObjectPropertyPairContext *> FormalParser::AnonymousObjectPropertyListContext::objectPropertyPair() {
  return getRuleContexts<FormalParser::ObjectPropertyPairContext>();
}

FormalParser::ObjectPropertyPairContext* FormalParser::AnonymousObjectPropertyListContext::objectPropertyPair(size_t i) {
  return getRuleContext<FormalParser::ObjectPropertyPairContext>(i);
}

std::vector<FormalParser::AnonymousObjectPropertyListSeparatorContext *> FormalParser::AnonymousObjectPropertyListContext::anonymousObjectPropertyListSeparator() {
  return getRuleContexts<FormalParser::AnonymousObjectPropertyListSeparatorContext>();
}

FormalParser::AnonymousObjectPropertyListSeparatorContext* FormalParser::AnonymousObjectPropertyListContext::anonymousObjectPropertyListSeparator(size_t i) {
  return getRuleContext<FormalParser::AnonymousObjectPropertyListSeparatorContext>(i);
}


size_t FormalParser::AnonymousObjectPropertyListContext::getRuleIndex() const {
  return FormalParser::RuleAnonymousObjectPropertyList;
}

size_t FormalParser::AnonymousObjectPropertyListContext::getContextId() const {
  return FormalParser::ContextIdAnonymousObjectPropertyList;
}


FormalParser::AnonymousObjectPropertyListContext* FormalParser::anonymousObjectPropertyList() {
  AnonymousObjectPropertyListContext *_localctx = _tracker.createInstance<AnonymousObjectPropertyListContext>(_ctx, getState());
  enterRule(_localctx, 224, FormalParser::RuleAnonymousObjectPropertyList);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1572);
    objectPropertyPair();
    setState(1578);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FormalParser::SemiColon

    || _la == FormalParser::Comma) {
      setState(1573);
      anonymousObjectPropertyListSeparator();
      setState(1574);
      objectPropertyPair();
      setState(1580);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }

    					dynamic_cast<AnonymousObjectPropertyListContext *>(_localctx)->isArrayList =  true;
    	
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ObjectPropertyPairContext ------------------------------------------------------------------

FormalParser::ObjectPropertyPairContext::ObjectPropertyPairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::ObjectPropertyPairContext::Colon() {
  return getToken(FormalParser::Colon, 0);
}

FormalParser::IdentifierContext* FormalParser::ObjectPropertyPairContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::Type_Context* FormalParser::ObjectPropertyPairContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}


size_t FormalParser::ObjectPropertyPairContext::getRuleIndex() const {
  return FormalParser::RuleObjectPropertyPair;
}

size_t FormalParser::ObjectPropertyPairContext::getContextId() const {
  return FormalParser::ContextIdObjectPropertyPair;
}


FormalParser::ObjectPropertyPairContext* FormalParser::objectPropertyPair() {
  ObjectPropertyPairContext *_localctx = _tracker.createInstance<ObjectPropertyPairContext>(_ctx, getState());
  enterRule(_localctx, 226, FormalParser::RuleObjectPropertyPair);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1583);
    dynamic_cast<ObjectPropertyPairContext *>(_localctx)->key = identifier();
    setState(1584);
    match(FormalParser::Colon);
    setState(1585);
    dynamic_cast<ObjectPropertyPairContext *>(_localctx)->value = type_(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GenericKindContext ------------------------------------------------------------------

FormalParser::GenericKindContext::GenericKindContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::GenericKindContext::Array() {
  return getToken(FormalParser::Array, 0);
}

tree::TerminalNode* FormalParser::GenericKindContext::Object() {
  return getToken(FormalParser::Object, 0);
}


size_t FormalParser::GenericKindContext::getRuleIndex() const {
  return FormalParser::RuleGenericKind;
}

size_t FormalParser::GenericKindContext::getContextId() const {
  return FormalParser::ContextIdGenericKind;
}


FormalParser::GenericKindContext* FormalParser::genericKind() {
  GenericKindContext *_localctx = _tracker.createInstance<GenericKindContext>(_ctx, getState());
  enterRule(_localctx, 228, FormalParser::RuleGenericKind);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1587);
    _la = _input->LA(1);
    if (!(_la == FormalParser::Array

    || _la == FormalParser::Object)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CommaGenericContext ------------------------------------------------------------------

FormalParser::CommaGenericContext::CommaGenericContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::CommaGenericContext::Comma() {
  return getToken(FormalParser::Comma, 0);
}

FormalParser::GenericKindContext* FormalParser::CommaGenericContext::genericKind() {
  return getRuleContext<FormalParser::GenericKindContext>(0);
}

FormalParser::Type_Context* FormalParser::CommaGenericContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}


size_t FormalParser::CommaGenericContext::getRuleIndex() const {
  return FormalParser::RuleCommaGeneric;
}

size_t FormalParser::CommaGenericContext::getContextId() const {
  return FormalParser::ContextIdCommaGeneric;
}


FormalParser::CommaGenericContext* FormalParser::commaGeneric() {
  CommaGenericContext *_localctx = _tracker.createInstance<CommaGenericContext>(_ctx, getState());
  enterRule(_localctx, 230, FormalParser::RuleCommaGeneric);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1589);
    dynamic_cast<CommaGenericContext *>(_localctx)->t0 = genericKind();
    setState(1590);
    match(FormalParser::Comma);
    setState(1591);
    dynamic_cast<CommaGenericContext *>(_localctx)->internalType = type_(0);

    	dynamic_cast<CommaGenericContext *>(_localctx)->type =  (dynamic_cast<CommaGenericContext *>(_localctx)->t0 != nullptr ? _input->getText(dynamic_cast<CommaGenericContext *>(_localctx)->t0->start, dynamic_cast<CommaGenericContext *>(_localctx)->t0->stop) : nullptr);

   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AngleGenericContext ------------------------------------------------------------------

FormalParser::AngleGenericContext::AngleGenericContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FormalParser::AngleGenericContext::LessThan() {
  return getTokens(FormalParser::LessThan);
}

tree::TerminalNode* FormalParser::AngleGenericContext::LessThan(size_t i) {
  return getToken(FormalParser::LessThan, i);
}

std::vector<tree::TerminalNode *> FormalParser::AngleGenericContext::MoreThan() {
  return getTokens(FormalParser::MoreThan);
}

tree::TerminalNode* FormalParser::AngleGenericContext::MoreThan(size_t i) {
  return getToken(FormalParser::MoreThan, i);
}

std::vector<FormalParser::GenericKindContext *> FormalParser::AngleGenericContext::genericKind() {
  return getRuleContexts<FormalParser::GenericKindContext>();
}

FormalParser::GenericKindContext* FormalParser::AngleGenericContext::genericKind(size_t i) {
  return getRuleContext<FormalParser::GenericKindContext>(i);
}

FormalParser::Type_Context* FormalParser::AngleGenericContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}

tree::TerminalNode* FormalParser::AngleGenericContext::RightShiftArithmetic() {
  return getToken(FormalParser::RightShiftArithmetic, 0);
}

tree::TerminalNode* FormalParser::AngleGenericContext::RightShiftLogical() {
  return getToken(FormalParser::RightShiftLogical, 0);
}


size_t FormalParser::AngleGenericContext::getRuleIndex() const {
  return FormalParser::RuleAngleGeneric;
}

size_t FormalParser::AngleGenericContext::getContextId() const {
  return FormalParser::ContextIdAngleGeneric;
}


FormalParser::AngleGenericContext* FormalParser::angleGeneric() {
  AngleGenericContext *_localctx = _tracker.createInstance<AngleGenericContext>(_ctx, getState());
  enterRule(_localctx, 232, FormalParser::RuleAngleGeneric);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1622);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 165, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1594);
      dynamic_cast<AngleGenericContext *>(_localctx)->t0 = genericKind();
      setState(1595);
      match(FormalParser::LessThan);
      setState(1596);
      dynamic_cast<AngleGenericContext *>(_localctx)->internalType = type_(0);
      setState(1597);
      match(FormalParser::MoreThan);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1599);
      dynamic_cast<AngleGenericContext *>(_localctx)->t0 = genericKind();
      setState(1600);
      match(FormalParser::LessThan);
      setState(1601);
      dynamic_cast<AngleGenericContext *>(_localctx)->t1 = genericKind();
      setState(1602);
      match(FormalParser::LessThan);
      setState(1603);
      dynamic_cast<AngleGenericContext *>(_localctx)->internalType = type_(0);
      setState(1607);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FormalParser::MoreThan: {
          setState(1604);
          match(FormalParser::MoreThan);
          setState(1605);
          match(FormalParser::MoreThan);
          break;
        }

        case FormalParser::RightShiftArithmetic: {
          setState(1606);
          match(FormalParser::RightShiftArithmetic);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1609);
      dynamic_cast<AngleGenericContext *>(_localctx)->t0 = genericKind();
      setState(1610);
      match(FormalParser::LessThan);
      setState(1611);
      dynamic_cast<AngleGenericContext *>(_localctx)->t1 = genericKind();
      setState(1612);
      match(FormalParser::LessThan);
      setState(1613);
      dynamic_cast<AngleGenericContext *>(_localctx)->t2 = genericKind();
      setState(1614);
      match(FormalParser::LessThan);
      setState(1615);
      dynamic_cast<AngleGenericContext *>(_localctx)->internalType = type_(0);
      setState(1620);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FormalParser::MoreThan: {
          setState(1616);
          match(FormalParser::MoreThan);
          setState(1617);
          match(FormalParser::MoreThan);
          setState(1618);
          match(FormalParser::MoreThan);
          break;
        }

        case FormalParser::RightShiftLogical: {
          setState(1619);
          match(FormalParser::RightShiftLogical);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    }
   _ctx->stop = _input->LT(-1);

    	//Correct in the visitor
    	dynamic_cast<AngleGenericContext *>(_localctx)->type =  (dynamic_cast<AngleGenericContext *>(_localctx)->t0 != nullptr ? _input->getText(dynamic_cast<AngleGenericContext *>(_localctx)->t0->start, dynamic_cast<AngleGenericContext *>(_localctx)->t0->stop) : nullptr);

  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ObjectOrArrayGenericTypeContext ------------------------------------------------------------------

FormalParser::ObjectOrArrayGenericTypeContext::ObjectOrArrayGenericTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::CommaGenericContext* FormalParser::ObjectOrArrayGenericTypeContext::commaGeneric() {
  return getRuleContext<FormalParser::CommaGenericContext>(0);
}

FormalParser::AngleGenericContext* FormalParser::ObjectOrArrayGenericTypeContext::angleGeneric() {
  return getRuleContext<FormalParser::AngleGenericContext>(0);
}


size_t FormalParser::ObjectOrArrayGenericTypeContext::getRuleIndex() const {
  return FormalParser::RuleObjectOrArrayGenericType;
}

size_t FormalParser::ObjectOrArrayGenericTypeContext::getContextId() const {
  return FormalParser::ContextIdObjectOrArrayGenericType;
}


FormalParser::ObjectOrArrayGenericTypeContext* FormalParser::objectOrArrayGenericType() {
  ObjectOrArrayGenericTypeContext *_localctx = _tracker.createInstance<ObjectOrArrayGenericTypeContext>(_ctx, getState());
  enterRule(_localctx, 234, FormalParser::RuleObjectOrArrayGenericType);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1626);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 166, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1624);
      commaGeneric();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1625);
      angleGeneric();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Type_Context ------------------------------------------------------------------

FormalParser::Type_Context::Type_Context(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t FormalParser::Type_Context::getRuleIndex() const {
  return FormalParser::RuleType_;
}

size_t FormalParser::Type_Context::getContextId() const {
  return FormalParser::ContextIdType_;
}

void FormalParser::Type_Context::copyFrom(Type_Context *ctx) {
  ParserRuleContext::copyFrom(ctx);
  this->type = ctx->type;
}

//----------------- UnionTypeContext ------------------------------------------------------------------

std::vector<FormalParser::Type_Context *> FormalParser::UnionTypeContext::type_() {
  return getRuleContexts<FormalParser::Type_Context>();
}

FormalParser::Type_Context* FormalParser::UnionTypeContext::type_(size_t i) {
  return getRuleContext<FormalParser::Type_Context>(i);
}

std::vector<tree::TerminalNode *> FormalParser::UnionTypeContext::BitOr() {
  return getTokens(FormalParser::BitOr);
}

tree::TerminalNode* FormalParser::UnionTypeContext::BitOr(size_t i) {
  return getToken(FormalParser::BitOr, i);
}


size_t FormalParser::UnionTypeContext::getContextId() const {
  return FormalParser::ContextIdUnionType;
}

FormalParser::UnionTypeContext::UnionTypeContext(Type_Context *ctx) { copyFrom(ctx); }


//----------------- GenericTypeContext ------------------------------------------------------------------

FormalParser::ObjectOrArrayGenericTypeContext* FormalParser::GenericTypeContext::objectOrArrayGenericType() {
  return getRuleContext<FormalParser::ObjectOrArrayGenericTypeContext>(0);
}


size_t FormalParser::GenericTypeContext::getContextId() const {
  return FormalParser::ContextIdGenericType;
}

FormalParser::GenericTypeContext::GenericTypeContext(Type_Context *ctx) { copyFrom(ctx); }


//----------------- ParenthesizedPrimTypeContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::ParenthesizedPrimTypeContext::OpenParen() {
  return getToken(FormalParser::OpenParen, 0);
}

tree::TerminalNode* FormalParser::ParenthesizedPrimTypeContext::CloseParen() {
  return getToken(FormalParser::CloseParen, 0);
}

FormalParser::Type_Context* FormalParser::ParenthesizedPrimTypeContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}


size_t FormalParser::ParenthesizedPrimTypeContext::getContextId() const {
  return FormalParser::ContextIdParenthesizedPrimType;
}

FormalParser::ParenthesizedPrimTypeContext::ParenthesizedPrimTypeContext(Type_Context *ctx) { copyFrom(ctx); }


//----------------- TupleTypeContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::TupleTypeContext::OpenBracket() {
  return getToken(FormalParser::OpenBracket, 0);
}

tree::TerminalNode* FormalParser::TupleTypeContext::CloseBracket() {
  return getToken(FormalParser::CloseBracket, 0);
}

FormalParser::TypeListContext* FormalParser::TupleTypeContext::typeList() {
  return getRuleContext<FormalParser::TypeListContext>(0);
}


size_t FormalParser::TupleTypeContext::getContextId() const {
  return FormalParser::ContextIdTupleType;
}

FormalParser::TupleTypeContext::TupleTypeContext(Type_Context *ctx) { copyFrom(ctx); }


//----------------- PrimitiveTypeContext ------------------------------------------------------------------

FormalParser::JsPrimitiveTypeContext* FormalParser::PrimitiveTypeContext::jsPrimitiveType() {
  return getRuleContext<FormalParser::JsPrimitiveTypeContext>(0);
}

FormalParser::ExtendedPrimitiveTypeContext* FormalParser::PrimitiveTypeContext::extendedPrimitiveType() {
  return getRuleContext<FormalParser::ExtendedPrimitiveTypeContext>(0);
}

tree::TerminalNode* FormalParser::PrimitiveTypeContext::Any() {
  return getToken(FormalParser::Any, 0);
}


size_t FormalParser::PrimitiveTypeContext::getContextId() const {
  return FormalParser::ContextIdPrimitiveType;
}

FormalParser::PrimitiveTypeContext::PrimitiveTypeContext(Type_Context *ctx) { copyFrom(ctx); }


//----------------- TypeReferenceContext ------------------------------------------------------------------

FormalParser::TypeNameContext* FormalParser::TypeReferenceContext::typeName() {
  return getRuleContext<FormalParser::TypeNameContext>(0);
}


size_t FormalParser::TypeReferenceContext::getContextId() const {
  return FormalParser::ContextIdTypeReference;
}

FormalParser::TypeReferenceContext::TypeReferenceContext(Type_Context *ctx) { copyFrom(ctx); }


//----------------- StructContext ------------------------------------------------------------------

tree::TerminalNode* FormalParser::StructContext::OpenBrace() {
  return getToken(FormalParser::OpenBrace, 0);
}

tree::TerminalNode* FormalParser::StructContext::CloseBrace() {
  return getToken(FormalParser::CloseBrace, 0);
}

FormalParser::AnonymousObjectPropertyListContext* FormalParser::StructContext::anonymousObjectPropertyList() {
  return getRuleContext<FormalParser::AnonymousObjectPropertyListContext>(0);
}


size_t FormalParser::StructContext::getContextId() const {
  return FormalParser::ContextIdStruct;
}

FormalParser::StructContext::StructContext(Type_Context *ctx) { copyFrom(ctx); }



FormalParser::Type_Context* FormalParser::type_() {
   return type_(0);
}

FormalParser::Type_Context* FormalParser::type_(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FormalParser::Type_Context *_localctx = _tracker.createInstance<Type_Context>(_ctx, parentState);
  FormalParser::Type_Context *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 236;
  enterRecursionRule(_localctx, 236, FormalParser::RuleType_, precedence);

    

  auto onExit = finally([=] {
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1661);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 169, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<PrimitiveTypeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(1629);
      jsPrimitiveType();

      		dynamic_cast<PrimitiveTypeContext *>(_localctx)->type =  _localctx->getText();
      	
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<PrimitiveTypeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1632);
      extendedPrimitiveType();

      		dynamic_cast<PrimitiveTypeContext *>(_localctx)->type =  _localctx->getText();
      	
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<PrimitiveTypeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1635);
      match(FormalParser::Any);

      		dynamic_cast<PrimitiveTypeContext *>(_localctx)->type =  _localctx->getText();
      	
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<GenericTypeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1637);
      objectOrArrayGenericType();

      		dynamic_cast<GenericTypeContext *>(_localctx)->type =  "genericType";
      	
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<TupleTypeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1640);
      match(FormalParser::OpenBracket);
      setState(1642);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 167, _ctx)) {
      case 1: {
        setState(1641);
        dynamic_cast<TupleTypeContext *>(_localctx)->elements = typeList();
        break;
      }

      }
      setState(1644);
      match(FormalParser::CloseBracket);

      		dynamic_cast<TupleTypeContext *>(_localctx)->type =  "tuple";
      	
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<StructContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1646);
      match(FormalParser::OpenBrace);
      setState(1648);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 168, _ctx)) {
      case 1: {
        setState(1647);
        dynamic_cast<StructContext *>(_localctx)->properties = anonymousObjectPropertyList();
        break;
      }

      }
      setState(1650);
      match(FormalParser::CloseBrace);

      		dynamic_cast<StructContext *>(_localctx)->type =  "struct";
      	
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<ParenthesizedPrimTypeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1652);

      if (!(this->allowParenthesesInType())) throw FailedPredicateException(this, "this->allowParenthesesInType()");
      setState(1653);
      match(FormalParser::OpenParen);
      setState(1654);
      dynamic_cast<ParenthesizedPrimTypeContext *>(_localctx)->internalType = type_(0);
      setState(1655);
      match(FormalParser::CloseParen);

      		dynamic_cast<ParenthesizedPrimTypeContext *>(_localctx)->type =  "parenthesizedPrimType";
      	
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<TypeReferenceContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(1658);
      dynamic_cast<TypeReferenceContext *>(_localctx)->typeName_ = typeName();

      		dynamic_cast<TypeReferenceContext *>(_localctx)->type =  "typeReference";
      	
      break;
    }

    }
    _ctx->stop = _input->LT(-1);
    setState(1674);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 171, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        auto newContext = _tracker.createInstance<UnionTypeContext>(_tracker.createInstance<Type_Context>(parentContext, parentState));
        _localctx = newContext;
        pushNewRecursionContext(newContext, startState, RuleType_);
        setState(1663);

        if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
        setState(1666); 
        _errHandler->sync(this);
        alt = 1;
        do {
          switch (alt) {
            case 1: {
                  setState(1664);
                  match(FormalParser::BitOr);
                  setState(1665);
                  type_(0);
                  break;
                }

          default:
            throw NoViableAltException(this);
          }
          setState(1668); 
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 170, _ctx);
        } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);

                  		dynamic_cast<UnionTypeContext *>(_localctx)->type =  "union";
                  	 
      }
      setState(1676);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 171, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- TypeAnnotContext ------------------------------------------------------------------

FormalParser::TypeAnnotContext::TypeAnnotContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::Type_Context* FormalParser::TypeAnnotContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}

FormalParser::EosContext* FormalParser::TypeAnnotContext::eos() {
  return getRuleContext<FormalParser::EosContext>(0);
}


size_t FormalParser::TypeAnnotContext::getRuleIndex() const {
  return FormalParser::RuleTypeAnnot;
}

size_t FormalParser::TypeAnnotContext::getContextId() const {
  return FormalParser::ContextIdTypeAnnot;
}


FormalParser::TypeAnnotContext* FormalParser::typeAnnot() {
  TypeAnnotContext *_localctx = _tracker.createInstance<TypeAnnotContext>(_ctx, getState());
  enterRule(_localctx, 238, FormalParser::RuleTypeAnnot);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1677);
    type_(0);
    setState(1678);
    eos();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypePredicateContext ------------------------------------------------------------------

FormalParser::TypePredicateContext::TypePredicateContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FormalParser::TypePredicateContext::Is() {
  return getToken(FormalParser::Is, 0);
}

FormalParser::IdentifierContext* FormalParser::TypePredicateContext::identifier() {
  return getRuleContext<FormalParser::IdentifierContext>(0);
}

FormalParser::Type_Context* FormalParser::TypePredicateContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}


size_t FormalParser::TypePredicateContext::getRuleIndex() const {
  return FormalParser::RuleTypePredicate;
}

size_t FormalParser::TypePredicateContext::getContextId() const {
  return FormalParser::ContextIdTypePredicate;
}


FormalParser::TypePredicateContext* FormalParser::typePredicate() {
  TypePredicateContext *_localctx = _tracker.createInstance<TypePredicateContext>(_ctx, getState());
  enterRule(_localctx, 240, FormalParser::RuleTypePredicate);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1680);
    dynamic_cast<TypePredicateContext *>(_localctx)->parameterName_ = identifier();
    setState(1681);
    match(FormalParser::Is);
    setState(1682);
    dynamic_cast<TypePredicateContext *>(_localctx)->typeAnnotation_ = type_(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionReturnTypeContext ------------------------------------------------------------------

FormalParser::FunctionReturnTypeContext::FunctionReturnTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FormalParser::Type_Context* FormalParser::FunctionReturnTypeContext::type_() {
  return getRuleContext<FormalParser::Type_Context>(0);
}

tree::TerminalNode* FormalParser::FunctionReturnTypeContext::Void() {
  return getToken(FormalParser::Void, 0);
}

FormalParser::TypePredicateContext* FormalParser::FunctionReturnTypeContext::typePredicate() {
  return getRuleContext<FormalParser::TypePredicateContext>(0);
}


size_t FormalParser::FunctionReturnTypeContext::getRuleIndex() const {
  return FormalParser::RuleFunctionReturnType;
}

size_t FormalParser::FunctionReturnTypeContext::getContextId() const {
  return FormalParser::ContextIdFunctionReturnType;
}


FormalParser::FunctionReturnTypeContext* FormalParser::functionReturnType() {
  FunctionReturnTypeContext *_localctx = _tracker.createInstance<FunctionReturnTypeContext>(_ctx, getState());
  enterRule(_localctx, 242, FormalParser::RuleFunctionReturnType);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(1687);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 172, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1684);
      type_(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1685);
      match(FormalParser::Void);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1686);
      typePredicate();
      break;
    }

    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

bool FormalParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
  switch (ruleIndex) {
    case 3: return patternSempred(dynamic_cast<PatternContext *>(context), predicateIndex);

    case 23: return statementSempred(dynamic_cast<StatementContext *>(context), predicateIndex);

    case 88: return expressionSempred(dynamic_cast<ExpressionContext *>(context), predicateIndex);

    case 89: return identifierSempred(dynamic_cast<IdentifierContext *>(context), predicateIndex);

    case 103: return eosSempred(dynamic_cast<EosContext *>(context), predicateIndex);

    case 108: return jsPrimitiveTypeSempred(dynamic_cast<JsPrimitiveTypeContext *>(context), predicateIndex);

    case 118: return type_Sempred(dynamic_cast<Type_Context *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool FormalParser::patternSempred(PatternContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return this->canBeFollowedByTypeAnnotation();
    case 1: return this->canBeFollowedByTypeAnnotation();
    case 2: return this->canBeFollowedByTypeAnnotation();

  default:
    break;
  }
  return true;
}

bool FormalParser::statementSempred(StatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 3: return this->notLineTerminator();
    case 4: return this->notLineTerminator();
    case 5: return this->notLineTerminator();
    case 6: return this->notLineTerminator();
    case 7: return this->notOpenBraceAndNotFunction();

  default:
    break;
  }
  return true;
}

bool FormalParser::expressionSempred(ExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 8: return precpred(_ctx, 35);
    case 9: return precpred(_ctx, 34);
    case 10: return precpred(_ctx, 33);
    case 11: return precpred(_ctx, 32);
    case 12: return precpred(_ctx, 31);
    case 13: return precpred(_ctx, 30);
    case 14: return precpred(_ctx, 29);
    case 15: return precpred(_ctx, 28);
    case 16: return precpred(_ctx, 27);
    case 17: return precpred(_ctx, 26);
    case 18: return precpred(_ctx, 25);
    case 19: return precpred(_ctx, 24);
    case 20: return precpred(_ctx, 23);
    case 21: return precpred(_ctx, 22);
    case 22: return precpred(_ctx, 21);
    case 23: return precpred(_ctx, 20);
    case 24: return precpred(_ctx, 18);
    case 25: return precpred(_ctx, 42);
    case 26: return precpred(_ctx, 40);
    case 27: return precpred(_ctx, 38);
    case 28: return this->notLineTerminator();
    case 29: return precpred(_ctx, 16);
    case 30: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool FormalParser::identifierSempred(IdentifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 31: return this->canBeFollowedByTypeAnnotation();
    case 32: return this->isParsingProperties();

  default:
    break;
  }
  return true;
}

bool FormalParser::eosSempred(EosContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 33: return this->lineTerminatorAhead();
    case 34: return this->closeBrace();

  default:
    break;
  }
  return true;
}

bool FormalParser::jsPrimitiveTypeSempred(JsPrimitiveTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 35: return this->allowUndefinedInType();

  default:
    break;
  }
  return true;
}

bool FormalParser::type_Sempred(Type_Context *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 36: return this->allowParenthesesInType();
    case 37: return precpred(_ctx, 4);

  default:
    break;
  }
  return true;
}

// Static vars and initialization.
std::vector<dfa::DFA> FormalParser::_decisionToDFA;
atn::PredictionContextCache FormalParser::_sharedContextCache;

// We own the ATN which in turn owns the ATN states.
atn::ATN FormalParser::_atn;
std::vector<uint16_t> FormalParser::_serializedATN;

std::vector<std::string> FormalParser::_ruleNames = {
  "input", "vardecl", "output", "pattern", "assignmentPattern", "initializer", 
  "parameterList", "parameter", "advancedParameterList", "requiredParameterList", 
  "advancedParameter", "optionalParameter", "requiredParameter", "accessibilityModifier", 
  "interfaceExtendsClause", "classOrInterfaceTypeList", "enumDeclaration", 
  "enumBody", "enumMemberList", "enumMember", "importAliasDeclaration", 
  "program", "sourceElement", "statement", "braceBlock", "declaration", 
  "functionDeclaration", "baseFunction", "baseClass", "statementList", "fromBlock", 
  "multipleImportStatement", "variableDeclaration", "variableDeclaratorList", 
  "variableDeclarator", "forInitStatement", "baseForXStatement", "varModifier", 
  "switchCaseList", "caseClauses", "caseClause", "defaultClause", "catchProduction", 
  "finallyProduction", "classBody", "classExtendsClause", "implementsClause", 
  "classElement", "methodDefinition", "propertyDefinition", "generatorMethod", 
  "generatorFunctionDeclaration", "generatorBlock", "generatorDefinition", 
  "iteratorBlock", "iteratorDefinition", "functionBody", "sourceArrayList", 
  "spreadElement", "arrayElement", "arrayElementArrayList", "arrayPatternElementArrayList", 
  "objectElement", "objectElementArrayList", "propertyName", "propertyKey", 
  "property", "assignmentProperty", "objectPatternElement", "objectPatternElementArrayList", 
  "getAccessor", "setAccessor", "argumentArrayList", "argument", "expressionSequence", 
  "updateOperator", "unaryOperator", "exponentiationOperator", "multiplicativeOperator", 
  "additiveOperator", "bitShiftOperator", "relationalOperator", "instanceofOperator", 
  "inOperator", "equalityOperator", "bitAndOperator", "bitOrOperator", "bitXorOperator", 
  "expression", "identifier", "metaPropertyIdentifier", "privateIdentifier", 
  "memberExpressionProperty", "arrowFunctionParameters", "arrowFunctionBody", 
  "assignmentOperator", "numericLiteral", "literal", "templateLiteral", 
  "templateStringAtom", "keyword", "getter", "setter", "eos", "assignable", 
  "typeAnnotation", "qualifiedName", "typeName", "jsPrimitiveType", "extendedPrimitiveType", 
  "typeList", "anonymousObjectPropertyListSeparator", "anonymousObjectPropertyList", 
  "objectPropertyPair", "genericKind", "commaGeneric", "angleGeneric", "objectOrArrayGenericType", 
  "type_", "typeAnnot", "typePredicate", "functionReturnType"
};

std::vector<std::string> FormalParser::_literalNames = {
  "", "", "", "", "'['", "']'", "'('", "')'", "'{'", "", "'}'", "';'", "','", 
  "'='", "'?'", "':'", "'...'", "'.'", "'++'", "'--'", "'+'", "'-'", "'~'", 
  "'!'", "'*'", "'/'", "'%'", "'**'", "'#'", "'>>'", "'<<'", "'>>>'", "'<'", 
  "'>'", "'<='", "'>='", "'=='", "'!='", "'==='", "'!=='", "'&'", "'^'", 
  "'|'", "'&&'", "'||'", "'??'", "'?.'", "'*='", "'/='", "'%='", "'**='", 
  "'+='", "'-='", "'<<='", "'>>='", "'>>>='", "'&='", "'^='", "'|='", "'=>'", 
  "'null'", "", "", "", "", "", "", "", "'break'", "'do'", "'instanceof'", 
  "'typeof'", "'case'", "'else'", "'new'", "'var'", "'catch'", "'finally'", 
  "'return'", "'void'", "'continue'", "'for'", "'switch'", "'while'", "'debugger'", 
  "'function'", "'this'", "'with'", "'default'", "'if'", "'throw'", "'delete'", 
  "'in'", "'of'", "'try'", "'as'", "'from'", "'readonly'", "'async'", "'class'", 
  "'enum'", "'extends'", "'super'", "'const'", "'export'", "'import'", "'implements'", 
  "'let'", "'private'", "'public'", "'interface'", "'package'", "'protected'", 
  "'static'", "'yield'", "'await'", "'any'", "'number'", "'boolean'", "'string'", 
  "'symbol'", "'undefined'", "'bigint'", "'int8'", "'int16'", "'int32'", 
  "'int64'", "'uint8'", "'uint16'", "'uint32'", "'uint64'", "'float'", "'double'", 
  "'decimal'", "'array'", "'object'", "'tuple'", "'struct'", "'union'", 
  "'variant'", "'type'", "'get'", "'set'", "'constructor'", "'namespace'", 
  "'module'", "'declare'", "'abstract'", "'is'", "'@'", "'''", "'\"'", "", 
  "", "", "", "", "", "", "", "", "'${'"
};

std::vector<std::string> FormalParser::_symbolicNames = {
  "", "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral", 
  "OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace", 
  "TemplateCloseBrace", "CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark", 
  "Colon", "Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus", 
  "BitNot", "Not", "Multiply", "Divide", "Modulus", "Exponentiation", "Hashtag", 
  "RightShiftArithmetic", "LeftShiftArithmetic", "RightShiftLogical", "LessThan", 
  "MoreThan", "LessThanEquals", "GreaterThanEquals", "Equals_", "NotEquals", 
  "IdentityEquals", "IdentityNotEquals", "BitAnd", "BitXOr", "BitOr", "And", 
  "Or", "DoubleQuestionMark", "OptionalChainingOperator", "MultiplyAssign", 
  "DivideAssign", "ModulusAssign", "ExponentiationAssign", "PlusAssign", 
  "MinusAssign", "LeftShiftArithmeticAssign", "RightShiftArithmeticAssign", 
  "RightShiftLogicalAssign", "BitAndAssign", "BitXorAssign", "BitOrAssign", 
  "ARROW", "NullLiteral", "BooleanLiteral", "DecimalLiteral", "HexIntegerLiteral", 
  "OctalIntegerLiteral", "OctalIntegerLiteral2", "BinaryIntegerLiteral", 
  "BigInt", "Break", "Do", "Instanceof", "Typeof", "Case", "Else", "New", 
  "Var", "Catch", "Finally", "Return", "Void", "Continue", "For", "Switch", 
  "While", "Debugger", "Function_", "This", "With", "Default", "If", "Throw", 
  "Delete", "In", "Of", "Try", "As", "From", "ReadOnly", "Async", "Class", 
  "Enum", "Extends", "Super", "Const", "Export", "Import", "Implements", 
  "Let", "Private", "Public", "Interface", "Package", "Protected", "Static", 
  "Yield", "Await", "Any", "Number", "Boolean", "String", "Symbol", "Undefined", 
  "BigIntAnnotation", "Int8", "Int16", "Int32", "Int64", "Uint8", "Uint16", 
  "Uint32", "Uint64", "Float", "Double", "Decimal", "Array", "Object", "Tuple", 
  "Struct", "Union", "Variant", "TypeAlias", "Get", "Set", "Constructor", 
  "Namespace", "Module", "Declare", "Abstract", "Is", "At", "SingQuote", 
  "DoubleQuote", "QuestionMarkFollowedByDecimalDirectly", "Identifier", 
  "StringLiteral", "BackTick", "WhiteSpaces", "LineTerminator", "HtmlComment", 
  "CDataComment", "UnexpectedCharacter", "TemplateStringStartExpression", 
  "TemplateStringAtom"
};

dfa::Vocabulary FormalParser::_vocabulary(_literalNames, _symbolicNames);

std::vector<std::string> FormalParser::_tokenNames;

FormalParser::Initializer::Initializer() {
	for (size_t i = 0; i < _symbolicNames.size(); ++i) {
		std::string name = _vocabulary.getLiteralName(i);
		if (name.empty()) {
			name = _vocabulary.getSymbolicName(i);
		}

		if (name.empty()) {
			_tokenNames.push_back("<INVALID>");
		} else {
      _tokenNames.push_back(name);
    }
	}

  _serializedATN = {
    0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, 
    0x3, 0xa4, 0x69c, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 
    0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, 
    0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, 
    0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, 
    0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, 
    0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15, 
    0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9, 
    0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 
    0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 
    0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 
    0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 
    0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 
    0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, 
    0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, 
    0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9, 
    0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35, 
    0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4, 
    0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c, 
    0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9, 
    0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42, 
    0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4, 
    0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4, 0x49, 
    0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9, 
    0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f, 
    0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x4, 0x52, 0x9, 0x52, 0x4, 
    0x53, 0x9, 0x53, 0x4, 0x54, 0x9, 0x54, 0x4, 0x55, 0x9, 0x55, 0x4, 0x56, 
    0x9, 0x56, 0x4, 0x57, 0x9, 0x57, 0x4, 0x58, 0x9, 0x58, 0x4, 0x59, 0x9, 
    0x59, 0x4, 0x5a, 0x9, 0x5a, 0x4, 0x5b, 0x9, 0x5b, 0x4, 0x5c, 0x9, 0x5c, 
    0x4, 0x5d, 0x9, 0x5d, 0x4, 0x5e, 0x9, 0x5e, 0x4, 0x5f, 0x9, 0x5f, 0x4, 
    0x60, 0x9, 0x60, 0x4, 0x61, 0x9, 0x61, 0x4, 0x62, 0x9, 0x62, 0x4, 0x63, 
    0x9, 0x63, 0x4, 0x64, 0x9, 0x64, 0x4, 0x65, 0x9, 0x65, 0x4, 0x66, 0x9, 
    0x66, 0x4, 0x67, 0x9, 0x67, 0x4, 0x68, 0x9, 0x68, 0x4, 0x69, 0x9, 0x69, 
    0x4, 0x6a, 0x9, 0x6a, 0x4, 0x6b, 0x9, 0x6b, 0x4, 0x6c, 0x9, 0x6c, 0x4, 
    0x6d, 0x9, 0x6d, 0x4, 0x6e, 0x9, 0x6e, 0x4, 0x6f, 0x9, 0x6f, 0x4, 0x70, 
    0x9, 0x70, 0x4, 0x71, 0x9, 0x71, 0x4, 0x72, 0x9, 0x72, 0x4, 0x73, 0x9, 
    0x73, 0x4, 0x74, 0x9, 0x74, 0x4, 0x75, 0x9, 0x75, 0x4, 0x76, 0x9, 0x76, 
    0x4, 0x77, 0x9, 0x77, 0x4, 0x78, 0x9, 0x78, 0x4, 0x79, 0x9, 0x79, 0x4, 
    0x7a, 0x9, 0x7a, 0x4, 0x7b, 0x9, 0x7b, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 
    0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 
    0x3, 0x5, 0x5, 0x5, 0x102, 0xa, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 
    0x5, 0x107, 0xa, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 
    0x5, 0x5, 0x10e, 0xa, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 
    0x5, 0x114, 0xa, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x119, 
    0xa, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x11f, 0xa, 
    0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 
    0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x7, 0x8, 0x12c, 0xa, 0x8, 
    0xc, 0x8, 0xe, 0x8, 0x12f, 0xb, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 
    0x9, 0x5, 0x9, 0x135, 0xa, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 
    0x7, 0xa, 0x13b, 0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0x13e, 0xb, 0xa, 0x3, 
    0xa, 0x3, 0xa, 0x5, 0xa, 0x142, 0xa, 0xa, 0x5, 0xa, 0x144, 0xa, 0xa, 
    0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0x149, 0xa, 0xb, 0xc, 0xb, 0xe, 
    0xb, 0x14c, 0xb, 0xb, 0x3, 0xc, 0x3, 0xc, 0x5, 0xc, 0x150, 0xa, 0xc, 
    0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x5, 0xd, 0x155, 0xa, 0xd, 0x3, 0xe, 0x3, 
    0xe, 0x5, 0xe, 0x159, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 
    0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x161, 0xa, 0xf, 0x3, 0x10, 0x3, 0x10, 
    0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x7, 0x11, 0x169, 0xa, 0x11, 
    0xc, 0x11, 0xe, 0x11, 0x16c, 0xb, 0x11, 0x3, 0x12, 0x5, 0x12, 0x16f, 
    0xa, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0x175, 
    0xa, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x5, 0x13, 0x17b, 
    0xa, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x7, 0x14, 0x180, 0xa, 0x14, 
    0xc, 0x14, 0xe, 0x14, 0x183, 0xb, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 
    0x5, 0x15, 0x188, 0xa, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 
    0x3, 0x16, 0x3, 0x17, 0x5, 0x17, 0x190, 0xa, 0x17, 0x3, 0x17, 0x3, 0x17, 
    0x3, 0x17, 0x3, 0x18, 0x5, 0x18, 0x196, 0xa, 0x18, 0x3, 0x18, 0x3, 0x18, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 
    0x19, 0x1a0, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x5, 0x19, 0x1a6, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1aa, 
    0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x19, 0x5, 0x19, 0x1b3, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x5, 0x19, 0x1b7, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 
    0x19, 0x1c3, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1da, 0xa, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1de, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x5, 0x19, 0x1e2, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x19, 0x5, 0x19, 0x1fd, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0x205, 0xa, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0x231, 0xa, 0x19, 0x3, 0x19, 
    0x5, 0x19, 0x234, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 
    0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0x24a, 0xa, 0x19, 0x3, 0x19, 
    0x3, 0x19, 0x5, 0x19, 0x24e, 0xa, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 
    0x252, 0xa, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 
    0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x5, 0x1b, 0x25c, 0xa, 0x1b, 0x3, 0x1c, 
    0x3, 0x1c, 0x3, 0x1c, 0x5, 0x1c, 0x261, 0xa, 0x1c, 0x3, 0x1d, 0x5, 0x1d, 
    0x264, 0xa, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x268, 0xa, 0x1d, 
    0x3, 0x1d, 0x5, 0x1d, 0x26b, 0xa, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x5, 0x1d, 
    0x26f, 0xa, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x274, 
    0xa, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x5, 0x1e, 0x279, 0xa, 0x1e, 
    0x3, 0x1e, 0x5, 0x1e, 0x27c, 0xa, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 
    0x280, 0xa, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x283, 0xa, 0x1e, 0x3, 0x1e, 
    0x5, 0x1e, 0x286, 0xa, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, 
    0x6, 0x1f, 0x28c, 0xa, 0x1f, 0xd, 0x1f, 0xe, 0x1f, 0x28d, 0x3, 0x20, 
    0x3, 0x20, 0x5, 0x20, 0x292, 0xa, 0x20, 0x3, 0x20, 0x3, 0x20, 0x5, 0x20, 
    0x296, 0xa, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 
    0x3, 0x21, 0x3, 0x21, 0x5, 0x21, 0x29f, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 
    0x3, 0x21, 0x3, 0x21, 0x7, 0x21, 0x2a5, 0xa, 0x21, 0xc, 0x21, 0xe, 0x21, 
    0x2a8, 0xb, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 
    0x5, 0x22, 0x2af, 0xa, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 
    0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x2b7, 0xa, 0x22, 0x3, 0x23, 0x3, 0x23, 
    0x3, 0x23, 0x7, 0x23, 0x2bc, 0xa, 0x23, 0xc, 0x23, 0xe, 0x23, 0x2bf, 
    0xb, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x5, 0x24, 0x2c4, 0xa, 0x24, 
    0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 
    0x24, 0x5, 0x24, 0x2cd, 0xa, 0x24, 0x3, 0x25, 0x3, 0x25, 0x5, 0x25, 
    0x2d1, 0xa, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 
    0x5, 0x26, 0x2d8, 0xa, 0x26, 0x3, 0x27, 0x3, 0x27, 0x3, 0x28, 0x3, 0x28, 
    0x5, 0x28, 0x2de, 0xa, 0x28, 0x3, 0x28, 0x3, 0x28, 0x5, 0x28, 0x2e2, 
    0xa, 0x28, 0x5, 0x28, 0x2e4, 0xa, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x29, 
    0x6, 0x29, 0x2e9, 0xa, 0x29, 0xd, 0x29, 0xe, 0x29, 0x2ea, 0x3, 0x2a, 
    0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x5, 0x2a, 0x2f1, 0xa, 0x2a, 0x3, 0x2a, 
    0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x5, 0x2b, 0x2f8, 0xa, 0x2b, 
    0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 
    0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2e, 
    0x3, 0x2e, 0x7, 0x2e, 0x308, 0xa, 0x2e, 0xc, 0x2e, 0xe, 0x2e, 0x30b, 
    0xb, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 
    0x30, 0x3, 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x5, 0x31, 0x317, 
    0xa, 0x31, 0x3, 0x32, 0x5, 0x32, 0x31a, 0xa, 0x32, 0x3, 0x32, 0x5, 0x32, 
    0x31d, 0xa, 0x32, 0x3, 0x32, 0x5, 0x32, 0x320, 0xa, 0x32, 0x3, 0x32, 
    0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x325, 0xa, 0x32, 0x3, 0x32, 0x3, 0x32, 
    0x3, 0x32, 0x5, 0x32, 0x32a, 0xa, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 
    0x5, 0x32, 0x32f, 0xa, 0x32, 0x3, 0x32, 0x5, 0x32, 0x332, 0xa, 0x32, 
    0x3, 0x32, 0x5, 0x32, 0x335, 0xa, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 
    0x339, 0xa, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x33e, 
    0xa, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x343, 0xa, 0x32, 
    0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x349, 0xa, 0x32, 
    0x3, 0x33, 0x5, 0x33, 0x34c, 0xa, 0x33, 0x3, 0x33, 0x5, 0x33, 0x34f, 
    0xa, 0x33, 0x3, 0x33, 0x5, 0x33, 0x352, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 
    0x5, 0x33, 0x356, 0xa, 0x33, 0x3, 0x33, 0x5, 0x33, 0x359, 0xa, 0x33, 
    0x3, 0x33, 0x5, 0x33, 0x35c, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 
    0x3, 0x34, 0x5, 0x34, 0x362, 0xa, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 
    0x5, 0x34, 0x367, 0xa, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 
    0x3, 0x34, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x5, 0x35, 0x371, 0xa, 0x35, 
    0x3, 0x35, 0x3, 0x35, 0x5, 0x35, 0x375, 0xa, 0x35, 0x3, 0x35, 0x3, 0x35, 
    0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 
    0x36, 0x7, 0x36, 0x380, 0xa, 0x36, 0xc, 0x36, 0xe, 0x36, 0x383, 0xb, 
    0x36, 0x3, 0x36, 0x5, 0x36, 0x386, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 
    0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 
    0x38, 0x7, 0x38, 0x391, 0xa, 0x38, 0xc, 0x38, 0xe, 0x38, 0x394, 0xb, 
    0x38, 0x3, 0x38, 0x5, 0x38, 0x397, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 
    0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x5, 0x39, 0x3a0, 
    0xa, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 
    0x3a, 0x5, 0x3a, 0x3a8, 0xa, 0x3a, 0x3, 0x3b, 0x6, 0x3b, 0x3ab, 0xa, 
    0x3b, 0xd, 0x3b, 0xe, 0x3b, 0x3ac, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 
    0x3, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x5, 0x3d, 0x3b5, 0xa, 0x3d, 0x3, 0x3e, 
    0x7, 0x3e, 0x3b8, 0xa, 0x3e, 0xc, 0x3e, 0xe, 0x3e, 0x3bb, 0xb, 0x3e, 
    0x3, 0x3e, 0x3, 0x3e, 0x5, 0x3e, 0x3bf, 0xa, 0x3e, 0x3, 0x3e, 0x6, 0x3e, 
    0x3c2, 0xa, 0x3e, 0xd, 0x3e, 0xe, 0x3e, 0x3c3, 0x3, 0x3e, 0x7, 0x3e, 
    0x3c7, 0xa, 0x3e, 0xc, 0x3e, 0xe, 0x3e, 0x3ca, 0xb, 0x3e, 0x3, 0x3e, 
    0x7, 0x3e, 0x3cd, 0xa, 0x3e, 0xc, 0x3e, 0xe, 0x3e, 0x3d0, 0xb, 0x3e, 
    0x3, 0x3f, 0x7, 0x3f, 0x3d3, 0xa, 0x3f, 0xc, 0x3f, 0xe, 0x3f, 0x3d6, 
    0xb, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x3db, 0xa, 0x3f, 
    0x3, 0x3f, 0x6, 0x3f, 0x3de, 0xa, 0x3f, 0xd, 0x3f, 0xe, 0x3f, 0x3df, 
    0x3, 0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x3e4, 0xa, 0x3f, 0x7, 0x3f, 0x3e6, 
    0xa, 0x3f, 0xc, 0x3f, 0xe, 0x3f, 0x3e9, 0xb, 0x3f, 0x3, 0x3f, 0x7, 0x3f, 
    0x3ec, 0xa, 0x3f, 0xc, 0x3f, 0xe, 0x3f, 0x3ef, 0xb, 0x3f, 0x3, 0x40, 
    0x3, 0x40, 0x5, 0x40, 0x3f3, 0xa, 0x40, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 
    0x7, 0x41, 0x3f8, 0xa, 0x41, 0xc, 0x41, 0xe, 0x41, 0x3fb, 0xb, 0x41, 
    0x3, 0x41, 0x5, 0x41, 0x3fe, 0xa, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 
    0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 
    0x42, 0x3, 0x42, 0x5, 0x42, 0x40b, 0xa, 0x42, 0x3, 0x43, 0x3, 0x43, 
    0x5, 0x43, 0x40f, 0xa, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 
    0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 
    0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 
    0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 
    0x44, 0x5, 0x44, 0x429, 0xa, 0x44, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 
    0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x5, 0x45, 0x431, 0xa, 0x45, 0x3, 0x46, 
    0x3, 0x46, 0x5, 0x46, 0x435, 0xa, 0x46, 0x3, 0x47, 0x3, 0x47, 0x3, 0x47, 
    0x7, 0x47, 0x43a, 0xa, 0x47, 0xc, 0x47, 0xe, 0x47, 0x43d, 0xb, 0x47, 
    0x3, 0x47, 0x5, 0x47, 0x440, 0xa, 0x47, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48, 
    0x3, 0x48, 0x5, 0x48, 0x446, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48, 
    0x3, 0x48, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x5, 0x49, 0x450, 
    0xa, 0x49, 0x3, 0x49, 0x5, 0x49, 0x453, 0xa, 0x49, 0x3, 0x49, 0x3, 0x49, 
    0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x7, 
    0x4a, 0x45d, 0xa, 0x4a, 0xc, 0x4a, 0xe, 0x4a, 0x460, 0xb, 0x4a, 0x3, 
    0x4b, 0x3, 0x4b, 0x5, 0x4b, 0x464, 0xa, 0x4b, 0x3, 0x4c, 0x3, 0x4c, 
    0x3, 0x4c, 0x7, 0x4c, 0x469, 0xa, 0x4c, 0xc, 0x4c, 0xe, 0x4c, 0x46c, 
    0xb, 0x4c, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4e, 0x3, 
    0x4e, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3, 0x51, 0x3, 0x51, 
    0x3, 0x52, 0x3, 0x52, 0x3, 0x53, 0x3, 0x53, 0x3, 0x54, 0x3, 0x54, 0x3, 
    0x55, 0x3, 0x55, 0x3, 0x56, 0x3, 0x56, 0x3, 0x57, 0x3, 0x57, 0x3, 0x58, 
    0x3, 0x58, 0x3, 0x59, 0x3, 0x59, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x5, 0x5a, 0x490, 0xa, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x5, 0x5a, 0x494, 0xa, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x5, 0x5a, 0x4a6, 0xa, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x5, 0x5a, 0x4ca, 0xa, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x5, 0x5a, 0x4ed, 0xa, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x5, 0x5a, 0x4f3, 0xa, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x5, 0x5a, 
    0x4f7, 0xa, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x5, 0x5a, 0x557, 
    0xa, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x5, 0x5a, 0x55b, 0xa, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 
    0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 
    0x3, 0x5a, 0x3, 0x5a, 0x5, 0x5a, 0x56d, 0xa, 0x5a, 0x3, 0x5a, 0x5, 0x5a, 
    0x570, 0xa, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x7, 0x5a, 0x574, 0xa, 0x5a, 
    0xc, 0x5a, 0xe, 0x5a, 0x577, 0xb, 0x5a, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 
    0x5, 0x5b, 0x57c, 0xa, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 
    0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x5, 
    0x5b, 0x588, 0xa, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 
    0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x5, 0x5b, 0x591, 0xa, 0x5b, 0x5, 0x5b, 
    0x593, 0xa, 0x5b, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x5, 0x5c, 
    0x599, 0xa, 0x5c, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5e, 
    0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 
    0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 
    0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 
    0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x5, 0x5e, 0x5b6, 0xa, 0x5e, 0x3, 0x5f, 
    0x3, 0x5f, 0x5, 0x5f, 0x5ba, 0xa, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x5, 0x5f, 
    0x5be, 0xa, 0x5f, 0x3, 0x60, 0x3, 0x60, 0x5, 0x60, 0x5c2, 0xa, 0x60, 
    0x3, 0x61, 0x3, 0x61, 0x3, 0x62, 0x3, 0x62, 0x3, 0x63, 0x3, 0x63, 0x3, 
    0x63, 0x3, 0x63, 0x3, 0x63, 0x3, 0x63, 0x3, 0x63, 0x5, 0x63, 0x5cf, 
    0xa, 0x63, 0x3, 0x64, 0x3, 0x64, 0x7, 0x64, 0x5d3, 0xa, 0x64, 0xc, 0x64, 
    0xe, 0x64, 0x5d6, 0xb, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x65, 0x3, 0x65, 
    0x3, 0x65, 0x3, 0x65, 0x3, 0x65, 0x5, 0x65, 0x5df, 0xa, 0x65, 0x3, 0x66, 
    0x3, 0x66, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67, 0x3, 0x68, 0x3, 0x68, 0x3, 
    0x68, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x5, 0x69, 0x5ed, 
    0xa, 0x69, 0x3, 0x6a, 0x3, 0x6a, 0x3, 0x6a, 0x3, 0x6a, 0x5, 0x6a, 0x5f3, 
    0xa, 0x6a, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6c, 0x3, 
    0x6c, 0x3, 0x6c, 0x6, 0x6c, 0x5fc, 0xa, 0x6c, 0xd, 0x6c, 0xe, 0x6c, 
    0x5fd, 0x3, 0x6c, 0x3, 0x6c, 0x3, 0x6c, 0x3, 0x6c, 0x3, 0x6c, 0x6, 0x6c, 
    0x605, 0xa, 0x6c, 0xd, 0x6c, 0xe, 0x6c, 0x606, 0x5, 0x6c, 0x609, 0xa, 
    0x6c, 0x3, 0x6d, 0x3, 0x6d, 0x5, 0x6d, 0x60d, 0xa, 0x6d, 0x3, 0x6e, 
    0x3, 0x6e, 0x3, 0x6e, 0x3, 0x6e, 0x3, 0x6e, 0x3, 0x6e, 0x3, 0x6e, 0x3, 
    0x6e, 0x5, 0x6e, 0x617, 0xa, 0x6e, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x70, 
    0x3, 0x70, 0x3, 0x70, 0x7, 0x70, 0x61e, 0xa, 0x70, 0xc, 0x70, 0xe, 0x70, 
    0x621, 0xb, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x71, 0x3, 0x71, 0x3, 0x72, 
    0x3, 0x72, 0x3, 0x72, 0x3, 0x72, 0x7, 0x72, 0x62b, 0xa, 0x72, 0xc, 0x72, 
    0xe, 0x72, 0x62e, 0xb, 0x72, 0x3, 0x72, 0x3, 0x72, 0x3, 0x73, 0x3, 0x73, 
    0x3, 0x73, 0x3, 0x73, 0x3, 0x74, 0x3, 0x74, 0x3, 0x75, 0x3, 0x75, 0x3, 
    0x75, 0x3, 0x75, 0x3, 0x75, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 
    0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 
    0x76, 0x3, 0x76, 0x3, 0x76, 0x5, 0x76, 0x64a, 0xa, 0x76, 0x3, 0x76, 
    0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 
    0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x5, 0x76, 0x657, 0xa, 0x76, 
    0x5, 0x76, 0x659, 0xa, 0x76, 0x3, 0x77, 0x3, 0x77, 0x5, 0x77, 0x65d, 
    0xa, 0x77, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 
    0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 
    0x3, 0x78, 0x3, 0x78, 0x5, 0x78, 0x66d, 0xa, 0x78, 0x3, 0x78, 0x3, 0x78, 
    0x3, 0x78, 0x3, 0x78, 0x5, 0x78, 0x673, 0xa, 0x78, 0x3, 0x78, 0x3, 0x78, 
    0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 
    0x78, 0x3, 0x78, 0x3, 0x78, 0x5, 0x78, 0x680, 0xa, 0x78, 0x3, 0x78, 
    0x3, 0x78, 0x3, 0x78, 0x6, 0x78, 0x685, 0xa, 0x78, 0xd, 0x78, 0xe, 0x78, 
    0x686, 0x3, 0x78, 0x3, 0x78, 0x7, 0x78, 0x68b, 0xa, 0x78, 0xc, 0x78, 
    0xe, 0x78, 0x68e, 0xb, 0x78, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x3, 0x7a, 
    0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b, 0x5, 
    0x7b, 0x69a, 0xa, 0x7b, 0x3, 0x7b, 0x2, 0x4, 0xb2, 0xee, 0x7c, 0x2, 
    0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 
    0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 
    0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 
    0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, 0x64, 
    0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 
    0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 
    0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 
    0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 0xc0, 0xc2, 0xc4, 
    0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 
    0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 
    0x2, 0x11, 0x5, 0x2, 0x4d, 0x4d, 0x69, 0x69, 0x6d, 0x6d, 0x3, 0x2, 0x14, 
    0x15, 0x6, 0x2, 0x16, 0x19, 0x49, 0x49, 0x51, 0x51, 0x5d, 0x5d, 0x3, 
    0x2, 0x1a, 0x1c, 0x3, 0x2, 0x16, 0x17, 0x3, 0x2, 0x1f, 0x21, 0x3, 0x2, 
    0x22, 0x25, 0x3, 0x2, 0x26, 0x28, 0x3, 0x2, 0x98, 0x99, 0x4, 0x2, 0xf, 
    0xf, 0x31, 0x3c, 0x3, 0x2, 0x40, 0x44, 0x6, 0x2, 0x46, 0x60, 0x62, 0x74, 
    0x79, 0x79, 0x8e, 0x90, 0x3, 0x2, 0x7d, 0x87, 0x3, 0x2, 0xd, 0xe, 0x3, 
    0x2, 0x88, 0x89, 0x2, 0x738, 0x2, 0xf6, 0x3, 0x2, 0x2, 0x2, 0x4, 0xf9, 
    0x3, 0x2, 0x2, 0x2, 0x6, 0xfc, 0x3, 0x2, 0x2, 0x2, 0x8, 0x11e, 0x3, 
    0x2, 0x2, 0x2, 0xa, 0x120, 0x3, 0x2, 0x2, 0x2, 0xc, 0x125, 0x3, 0x2, 
    0x2, 0x2, 0xe, 0x128, 0x3, 0x2, 0x2, 0x2, 0x10, 0x134, 0x3, 0x2, 0x2, 
    0x2, 0x12, 0x143, 0x3, 0x2, 0x2, 0x2, 0x14, 0x145, 0x3, 0x2, 0x2, 0x2, 
    0x16, 0x14f, 0x3, 0x2, 0x2, 0x2, 0x18, 0x151, 0x3, 0x2, 0x2, 0x2, 0x1a, 
    0x156, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x160, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x162, 
    0x3, 0x2, 0x2, 0x2, 0x20, 0x165, 0x3, 0x2, 0x2, 0x2, 0x22, 0x16e, 0x3, 
    0x2, 0x2, 0x2, 0x24, 0x178, 0x3, 0x2, 0x2, 0x2, 0x26, 0x17c, 0x3, 0x2, 
    0x2, 0x2, 0x28, 0x184, 0x3, 0x2, 0x2, 0x2, 0x2a, 0x189, 0x3, 0x2, 0x2, 
    0x2, 0x2c, 0x18f, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x195, 0x3, 0x2, 0x2, 0x2, 
    0x30, 0x24d, 0x3, 0x2, 0x2, 0x2, 0x32, 0x24f, 0x3, 0x2, 0x2, 0x2, 0x34, 
    0x25b, 0x3, 0x2, 0x2, 0x2, 0x36, 0x25d, 0x3, 0x2, 0x2, 0x2, 0x38, 0x263, 
    0x3, 0x2, 0x2, 0x2, 0x3a, 0x278, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x28b, 0x3, 
    0x2, 0x2, 0x2, 0x3e, 0x291, 0x3, 0x2, 0x2, 0x2, 0x40, 0x29e, 0x3, 0x2, 
    0x2, 0x2, 0x42, 0x2b6, 0x3, 0x2, 0x2, 0x2, 0x44, 0x2b8, 0x3, 0x2, 0x2, 
    0x2, 0x46, 0x2cc, 0x3, 0x2, 0x2, 0x2, 0x48, 0x2d0, 0x3, 0x2, 0x2, 0x2, 
    0x4a, 0x2d7, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x2d9, 0x3, 0x2, 0x2, 0x2, 0x4e, 
    0x2db, 0x3, 0x2, 0x2, 0x2, 0x50, 0x2e8, 0x3, 0x2, 0x2, 0x2, 0x52, 0x2ec, 
    0x3, 0x2, 0x2, 0x2, 0x54, 0x2f4, 0x3, 0x2, 0x2, 0x2, 0x56, 0x2fb, 0x3, 
    0x2, 0x2, 0x2, 0x58, 0x302, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x305, 0x3, 0x2, 
    0x2, 0x2, 0x5c, 0x30e, 0x3, 0x2, 0x2, 0x2, 0x5e, 0x311, 0x3, 0x2, 0x2, 
    0x2, 0x60, 0x316, 0x3, 0x2, 0x2, 0x2, 0x62, 0x348, 0x3, 0x2, 0x2, 0x2, 
    0x64, 0x34b, 0x3, 0x2, 0x2, 0x2, 0x66, 0x361, 0x3, 0x2, 0x2, 0x2, 0x68, 
    0x36d, 0x3, 0x2, 0x2, 0x2, 0x6a, 0x37b, 0x3, 0x2, 0x2, 0x2, 0x6c, 0x389, 
    0x3, 0x2, 0x2, 0x2, 0x6e, 0x38c, 0x3, 0x2, 0x2, 0x2, 0x70, 0x39a, 0x3, 
    0x2, 0x2, 0x2, 0x72, 0x3a7, 0x3, 0x2, 0x2, 0x2, 0x74, 0x3aa, 0x3, 0x2, 
    0x2, 0x2, 0x76, 0x3ae, 0x3, 0x2, 0x2, 0x2, 0x78, 0x3b4, 0x3, 0x2, 0x2, 
    0x2, 0x7a, 0x3b9, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x3d4, 0x3, 0x2, 0x2, 0x2, 
    0x7e, 0x3f2, 0x3, 0x2, 0x2, 0x2, 0x80, 0x3f4, 0x3, 0x2, 0x2, 0x2, 0x82, 
    0x40a, 0x3, 0x2, 0x2, 0x2, 0x84, 0x40e, 0x3, 0x2, 0x2, 0x2, 0x86, 0x428, 
    0x3, 0x2, 0x2, 0x2, 0x88, 0x430, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x434, 0x3, 
    0x2, 0x2, 0x2, 0x8c, 0x436, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x441, 0x3, 0x2, 
    0x2, 0x2, 0x90, 0x44b, 0x3, 0x2, 0x2, 0x2, 0x92, 0x459, 0x3, 0x2, 0x2, 
    0x2, 0x94, 0x463, 0x3, 0x2, 0x2, 0x2, 0x96, 0x465, 0x3, 0x2, 0x2, 0x2, 
    0x98, 0x46f, 0x3, 0x2, 0x2, 0x2, 0x9a, 0x471, 0x3, 0x2, 0x2, 0x2, 0x9c, 
    0x473, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x475, 0x3, 0x2, 0x2, 0x2, 0xa0, 0x477, 
    0x3, 0x2, 0x2, 0x2, 0xa2, 0x479, 0x3, 0x2, 0x2, 0x2, 0xa4, 0x47b, 0x3, 
    0x2, 0x2, 0x2, 0xa6, 0x47d, 0x3, 0x2, 0x2, 0x2, 0xa8, 0x47f, 0x3, 0x2, 
    0x2, 0x2, 0xaa, 0x481, 0x3, 0x2, 0x2, 0x2, 0xac, 0x483, 0x3, 0x2, 0x2, 
    0x2, 0xae, 0x485, 0x3, 0x2, 0x2, 0x2, 0xb0, 0x487, 0x3, 0x2, 0x2, 0x2, 
    0xb2, 0x4f6, 0x3, 0x2, 0x2, 0x2, 0xb4, 0x592, 0x3, 0x2, 0x2, 0x2, 0xb6, 
    0x598, 0x3, 0x2, 0x2, 0x2, 0xb8, 0x59a, 0x3, 0x2, 0x2, 0x2, 0xba, 0x5b5, 
    0x3, 0x2, 0x2, 0x2, 0xbc, 0x5bd, 0x3, 0x2, 0x2, 0x2, 0xbe, 0x5c1, 0x3, 
    0x2, 0x2, 0x2, 0xc0, 0x5c3, 0x3, 0x2, 0x2, 0x2, 0xc2, 0x5c5, 0x3, 0x2, 
    0x2, 0x2, 0xc4, 0x5ce, 0x3, 0x2, 0x2, 0x2, 0xc6, 0x5d0, 0x3, 0x2, 0x2, 
    0x2, 0xc8, 0x5de, 0x3, 0x2, 0x2, 0x2, 0xca, 0x5e0, 0x3, 0x2, 0x2, 0x2, 
    0xcc, 0x5e2, 0x3, 0x2, 0x2, 0x2, 0xce, 0x5e5, 0x3, 0x2, 0x2, 0x2, 0xd0, 
    0x5ec, 0x3, 0x2, 0x2, 0x2, 0xd2, 0x5f2, 0x3, 0x2, 0x2, 0x2, 0xd4, 0x5f4, 
    0x3, 0x2, 0x2, 0x2, 0xd6, 0x608, 0x3, 0x2, 0x2, 0x2, 0xd8, 0x60c, 0x3, 
    0x2, 0x2, 0x2, 0xda, 0x616, 0x3, 0x2, 0x2, 0x2, 0xdc, 0x618, 0x3, 0x2, 
    0x2, 0x2, 0xde, 0x61a, 0x3, 0x2, 0x2, 0x2, 0xe0, 0x624, 0x3, 0x2, 0x2, 
    0x2, 0xe2, 0x626, 0x3, 0x2, 0x2, 0x2, 0xe4, 0x631, 0x3, 0x2, 0x2, 0x2, 
    0xe6, 0x635, 0x3, 0x2, 0x2, 0x2, 0xe8, 0x637, 0x3, 0x2, 0x2, 0x2, 0xea, 
    0x658, 0x3, 0x2, 0x2, 0x2, 0xec, 0x65c, 0x3, 0x2, 0x2, 0x2, 0xee, 0x67f, 
    0x3, 0x2, 0x2, 0x2, 0xf0, 0x68f, 0x3, 0x2, 0x2, 0x2, 0xf2, 0x692, 0x3, 
    0x2, 0x2, 0x2, 0xf4, 0x699, 0x3, 0x2, 0x2, 0x2, 0xf6, 0xf7, 0x5, 0x96, 
    0x4c, 0x2, 0xf7, 0xf8, 0x5, 0xd0, 0x69, 0x2, 0xf8, 0x3, 0x3, 0x2, 0x2, 
    0x2, 0xf9, 0xfa, 0x5, 0x42, 0x22, 0x2, 0xfa, 0xfb, 0x5, 0xd0, 0x69, 
    0x2, 0xfb, 0x5, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x5, 0xd2, 0x6a, 0x2, 
    0xfd, 0xfe, 0x5, 0xd0, 0x69, 0x2, 0xfe, 0x7, 0x3, 0x2, 0x2, 0x2, 0xff, 
    0x101, 0x7, 0xa, 0x2, 0x2, 0x100, 0x102, 0x5, 0x8c, 0x47, 0x2, 0x101, 
    0x100, 0x3, 0x2, 0x2, 0x2, 0x101, 0x102, 0x3, 0x2, 0x2, 0x2, 0x102, 
    0x103, 0x3, 0x2, 0x2, 0x2, 0x103, 0x106, 0x7, 0xc, 0x2, 0x2, 0x104, 
    0x105, 0x6, 0x5, 0x2, 0x2, 0x105, 0x107, 0x5, 0xd4, 0x6b, 0x2, 0x106, 
    0x104, 0x3, 0x2, 0x2, 0x2, 0x106, 0x107, 0x3, 0x2, 0x2, 0x2, 0x107, 
    0x108, 0x3, 0x2, 0x2, 0x2, 0x108, 0x11f, 0x8, 0x5, 0x1, 0x2, 0x109, 
    0x10a, 0x7, 0x12, 0x2, 0x2, 0x10a, 0x10d, 0x5, 0x8, 0x5, 0x2, 0x10b, 
    0x10c, 0x6, 0x5, 0x3, 0x2, 0x10c, 0x10e, 0x5, 0xd4, 0x6b, 0x2, 0x10d, 
    0x10b, 0x3, 0x2, 0x2, 0x2, 0x10d, 0x10e, 0x3, 0x2, 0x2, 0x2, 0x10e, 
    0x10f, 0x3, 0x2, 0x2, 0x2, 0x10f, 0x110, 0x8, 0x5, 0x1, 0x2, 0x110, 
    0x11f, 0x3, 0x2, 0x2, 0x2, 0x111, 0x113, 0x7, 0x6, 0x2, 0x2, 0x112, 
    0x114, 0x5, 0x7c, 0x3f, 0x2, 0x113, 0x112, 0x3, 0x2, 0x2, 0x2, 0x113, 
    0x114, 0x3, 0x2, 0x2, 0x2, 0x114, 0x115, 0x3, 0x2, 0x2, 0x2, 0x115, 
    0x118, 0x7, 0x7, 0x2, 0x2, 0x116, 0x117, 0x6, 0x5, 0x4, 0x2, 0x117, 
    0x119, 0x5, 0xd4, 0x6b, 0x2, 0x118, 0x116, 0x3, 0x2, 0x2, 0x2, 0x118, 
    0x119, 0x3, 0x2, 0x2, 0x2, 0x119, 0x11a, 0x3, 0x2, 0x2, 0x2, 0x11a, 
    0x11f, 0x8, 0x5, 0x1, 0x2, 0x11b, 0x11c, 0x5, 0xb4, 0x5b, 0x2, 0x11c, 
    0x11d, 0x8, 0x5, 0x1, 0x2, 0x11d, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x11e, 
    0xff, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x109, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x111, 
    0x3, 0x2, 0x2, 0x2, 0x11e, 0x11b, 0x3, 0x2, 0x2, 0x2, 0x11f, 0x9, 0x3, 
    0x2, 0x2, 0x2, 0x120, 0x121, 0x5, 0x8, 0x5, 0x2, 0x121, 0x122, 0x5, 
    0xc0, 0x61, 0x2, 0x122, 0x123, 0x5, 0xb2, 0x5a, 0x2, 0x123, 0x124, 0x8, 
    0x6, 0x1, 0x2, 0x124, 0xb, 0x3, 0x2, 0x2, 0x2, 0x125, 0x126, 0x7, 0xf, 
    0x2, 0x2, 0x126, 0x127, 0x5, 0xb2, 0x5a, 0x2, 0x127, 0xd, 0x3, 0x2, 
    0x2, 0x2, 0x128, 0x12d, 0x5, 0x10, 0x9, 0x2, 0x129, 0x12a, 0x7, 0xe, 
    0x2, 0x2, 0x12a, 0x12c, 0x5, 0x10, 0x9, 0x2, 0x12b, 0x129, 0x3, 0x2, 
    0x2, 0x2, 0x12c, 0x12f, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x12b, 0x3, 0x2, 
    0x2, 0x2, 0x12d, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x130, 0x3, 0x2, 
    0x2, 0x2, 0x12f, 0x12d, 0x3, 0x2, 0x2, 0x2, 0x130, 0x131, 0x8, 0x8, 
    0x1, 0x2, 0x131, 0xf, 0x3, 0x2, 0x2, 0x2, 0x132, 0x135, 0x5, 0xa, 0x6, 
    0x2, 0x133, 0x135, 0x5, 0x8, 0x5, 0x2, 0x134, 0x132, 0x3, 0x2, 0x2, 
    0x2, 0x134, 0x133, 0x3, 0x2, 0x2, 0x2, 0x135, 0x11, 0x3, 0x2, 0x2, 0x2, 
    0x136, 0x144, 0x5, 0x76, 0x3c, 0x2, 0x137, 0x13c, 0x5, 0x16, 0xc, 0x2, 
    0x138, 0x139, 0x7, 0xe, 0x2, 0x2, 0x139, 0x13b, 0x5, 0x16, 0xc, 0x2, 
    0x13a, 0x138, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13e, 0x3, 0x2, 0x2, 0x2, 
    0x13c, 0x13a, 0x3, 0x2, 0x2, 0x2, 0x13c, 0x13d, 0x3, 0x2, 0x2, 0x2, 
    0x13d, 0x141, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13c, 0x3, 0x2, 0x2, 0x2, 
    0x13f, 0x140, 0x7, 0xe, 0x2, 0x2, 0x140, 0x142, 0x5, 0x76, 0x3c, 0x2, 
    0x141, 0x13f, 0x3, 0x2, 0x2, 0x2, 0x141, 0x142, 0x3, 0x2, 0x2, 0x2, 
    0x142, 0x144, 0x3, 0x2, 0x2, 0x2, 0x143, 0x136, 0x3, 0x2, 0x2, 0x2, 
    0x143, 0x137, 0x3, 0x2, 0x2, 0x2, 0x144, 0x13, 0x3, 0x2, 0x2, 0x2, 0x145, 
    0x14a, 0x5, 0x1a, 0xe, 0x2, 0x146, 0x147, 0x7, 0xe, 0x2, 0x2, 0x147, 
    0x149, 0x5, 0x1a, 0xe, 0x2, 0x148, 0x146, 0x3, 0x2, 0x2, 0x2, 0x149, 
    0x14c, 0x3, 0x2, 0x2, 0x2, 0x14a, 0x148, 0x3, 0x2, 0x2, 0x2, 0x14a, 
    0x14b, 0x3, 0x2, 0x2, 0x2, 0x14b, 0x15, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14a, 
    0x3, 0x2, 0x2, 0x2, 0x14d, 0x150, 0x5, 0x1a, 0xe, 0x2, 0x14e, 0x150, 
    0x5, 0x18, 0xd, 0x2, 0x14f, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x14f, 0x14e, 
    0x3, 0x2, 0x2, 0x2, 0x150, 0x17, 0x3, 0x2, 0x2, 0x2, 0x151, 0x154, 0x5, 
    0x8, 0x5, 0x2, 0x152, 0x155, 0x7, 0x10, 0x2, 0x2, 0x153, 0x155, 0x5, 
    0xc, 0x7, 0x2, 0x154, 0x152, 0x3, 0x2, 0x2, 0x2, 0x154, 0x153, 0x3, 
    0x2, 0x2, 0x2, 0x155, 0x19, 0x3, 0x2, 0x2, 0x2, 0x156, 0x158, 0x5, 0x8, 
    0x5, 0x2, 0x157, 0x159, 0x5, 0xd4, 0x6b, 0x2, 0x158, 0x157, 0x3, 0x2, 
    0x2, 0x2, 0x158, 0x159, 0x3, 0x2, 0x2, 0x2, 0x159, 0x1b, 0x3, 0x2, 0x2, 
    0x2, 0x15a, 0x15b, 0x7, 0x6f, 0x2, 0x2, 0x15b, 0x161, 0x8, 0xf, 0x1, 
    0x2, 0x15c, 0x15d, 0x7, 0x6e, 0x2, 0x2, 0x15d, 0x161, 0x8, 0xf, 0x1, 
    0x2, 0x15e, 0x15f, 0x7, 0x72, 0x2, 0x2, 0x15f, 0x161, 0x8, 0xf, 0x1, 
    0x2, 0x160, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x160, 0x15c, 0x3, 0x2, 0x2, 
    0x2, 0x160, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x161, 0x1d, 0x3, 0x2, 0x2, 0x2, 
    0x162, 0x163, 0x7, 0x67, 0x2, 0x2, 0x163, 0x164, 0x5, 0x20, 0x11, 0x2, 
    0x164, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x165, 0x16a, 0x5, 0xd8, 0x6d, 0x2, 
    0x166, 0x167, 0x7, 0xe, 0x2, 0x2, 0x167, 0x169, 0x5, 0xd8, 0x6d, 0x2, 
    0x168, 0x166, 0x3, 0x2, 0x2, 0x2, 0x169, 0x16c, 0x3, 0x2, 0x2, 0x2, 
    0x16a, 0x168, 0x3, 0x2, 0x2, 0x2, 0x16a, 0x16b, 0x3, 0x2, 0x2, 0x2, 
    0x16b, 0x21, 0x3, 0x2, 0x2, 0x2, 0x16c, 0x16a, 0x3, 0x2, 0x2, 0x2, 0x16d, 
    0x16f, 0x7, 0x69, 0x2, 0x2, 0x16e, 0x16d, 0x3, 0x2, 0x2, 0x2, 0x16e, 
    0x16f, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x170, 0x3, 0x2, 0x2, 0x2, 0x170, 
    0x171, 0x7, 0x66, 0x2, 0x2, 0x171, 0x172, 0x5, 0xb4, 0x5b, 0x2, 0x172, 
    0x174, 0x7, 0xa, 0x2, 0x2, 0x173, 0x175, 0x5, 0x24, 0x13, 0x2, 0x174, 
    0x173, 0x3, 0x2, 0x2, 0x2, 0x174, 0x175, 0x3, 0x2, 0x2, 0x2, 0x175, 
    0x176, 0x3, 0x2, 0x2, 0x2, 0x176, 0x177, 0x7, 0xc, 0x2, 0x2, 0x177, 
    0x23, 0x3, 0x2, 0x2, 0x2, 0x178, 0x17a, 0x5, 0x26, 0x14, 0x2, 0x179, 
    0x17b, 0x7, 0xe, 0x2, 0x2, 0x17a, 0x179, 0x3, 0x2, 0x2, 0x2, 0x17a, 
    0x17b, 0x3, 0x2, 0x2, 0x2, 0x17b, 0x25, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x181, 
    0x5, 0x28, 0x15, 0x2, 0x17d, 0x17e, 0x7, 0xe, 0x2, 0x2, 0x17e, 0x180, 
    0x5, 0x28, 0x15, 0x2, 0x17f, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x180, 0x183, 
    0x3, 0x2, 0x2, 0x2, 0x181, 0x17f, 0x3, 0x2, 0x2, 0x2, 0x181, 0x182, 
    0x3, 0x2, 0x2, 0x2, 0x182, 0x27, 0x3, 0x2, 0x2, 0x2, 0x183, 0x181, 0x3, 
    0x2, 0x2, 0x2, 0x184, 0x187, 0x5, 0x82, 0x42, 0x2, 0x185, 0x186, 0x7, 
    0xf, 0x2, 0x2, 0x186, 0x188, 0x5, 0xb2, 0x5a, 0x2, 0x187, 0x185, 0x3, 
    0x2, 0x2, 0x2, 0x187, 0x188, 0x3, 0x2, 0x2, 0x2, 0x188, 0x29, 0x3, 0x2, 
    0x2, 0x2, 0x189, 0x18a, 0x5, 0xb4, 0x5b, 0x2, 0x18a, 0x18b, 0x7, 0xf, 
    0x2, 0x2, 0x18b, 0x18c, 0x5, 0xd6, 0x6c, 0x2, 0x18c, 0x18d, 0x7, 0xd, 
    0x2, 0x2, 0x18d, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x18e, 0x190, 0x5, 0x74, 
    0x3b, 0x2, 0x18f, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x18f, 0x190, 0x3, 0x2, 
    0x2, 0x2, 0x190, 0x191, 0x3, 0x2, 0x2, 0x2, 0x191, 0x192, 0x7, 0x2, 
    0x2, 0x3, 0x192, 0x193, 0x8, 0x17, 0x1, 0x2, 0x193, 0x2d, 0x3, 0x2, 
    0x2, 0x2, 0x194, 0x196, 0x7, 0x6a, 0x2, 0x2, 0x195, 0x194, 0x3, 0x2, 
    0x2, 0x2, 0x195, 0x196, 0x3, 0x2, 0x2, 0x2, 0x196, 0x197, 0x3, 0x2, 
    0x2, 0x2, 0x197, 0x198, 0x5, 0x30, 0x19, 0x2, 0x198, 0x2f, 0x3, 0x2, 
    0x2, 0x2, 0x199, 0x19a, 0x5, 0x32, 0x1a, 0x2, 0x19a, 0x19b, 0x8, 0x19, 
    0x1, 0x2, 0x19b, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x19c, 0x19f, 0x7, 0x6b, 
    0x2, 0x2, 0x19d, 0x1a0, 0x5, 0x3e, 0x20, 0x2, 0x19e, 0x1a0, 0x5, 0x2a, 
    0x16, 0x2, 0x19f, 0x19d, 0x3, 0x2, 0x2, 0x2, 0x19f, 0x19e, 0x3, 0x2, 
    0x2, 0x2, 0x1a0, 0x1a1, 0x3, 0x2, 0x2, 0x2, 0x1a1, 0x1a2, 0x8, 0x19, 
    0x1, 0x2, 0x1a2, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x1a5, 0x7, 0x6a, 
    0x2, 0x2, 0x1a4, 0x1a6, 0x7, 0x5a, 0x2, 0x2, 0x1a5, 0x1a4, 0x3, 0x2, 
    0x2, 0x2, 0x1a5, 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1a9, 0x3, 0x2, 
    0x2, 0x2, 0x1a7, 0x1aa, 0x5, 0x3e, 0x20, 0x2, 0x1a8, 0x1aa, 0x5, 0x30, 
    0x19, 0x2, 0x1a9, 0x1a7, 0x3, 0x2, 0x2, 0x2, 0x1a9, 0x1a8, 0x3, 0x2, 
    0x2, 0x2, 0x1aa, 0x1ab, 0x3, 0x2, 0x2, 0x2, 0x1ab, 0x1ac, 0x8, 0x19, 
    0x1, 0x2, 0x1ac, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x1ad, 0x1ae, 0x7, 0xd, 
    0x2, 0x2, 0x1ae, 0x24e, 0x8, 0x19, 0x1, 0x2, 0x1af, 0x1b2, 0x7, 0x92, 
    0x2, 0x2, 0x1b0, 0x1b3, 0x5, 0xb4, 0x5b, 0x2, 0x1b1, 0x1b3, 0x5, 0xd6, 
    0x6c, 0x2, 0x1b2, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x1b2, 0x1b1, 0x3, 0x2, 
    0x2, 0x2, 0x1b3, 0x1b4, 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b6, 0x7, 0xa, 
    0x2, 0x2, 0x1b5, 0x1b7, 0x5, 0x3c, 0x1f, 0x2, 0x1b6, 0x1b5, 0x3, 0x2, 
    0x2, 0x2, 0x1b6, 0x1b7, 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1b8, 0x3, 0x2, 
    0x2, 0x2, 0x1b8, 0x1b9, 0x7, 0xc, 0x2, 0x2, 0x1b9, 0x1ba, 0x8, 0x19, 
    0x1, 0x2, 0x1ba, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x1bb, 0x1bc, 0x7, 0x5b, 
    0x2, 0x2, 0x1bc, 0x1bd, 0x7, 0x8, 0x2, 0x2, 0x1bd, 0x1be, 0x5, 0x96, 
    0x4c, 0x2, 0x1be, 0x1bf, 0x7, 0x9, 0x2, 0x2, 0x1bf, 0x1c2, 0x5, 0x30, 
    0x19, 0x2, 0x1c0, 0x1c1, 0x7, 0x4b, 0x2, 0x2, 0x1c1, 0x1c3, 0x5, 0x30, 
    0x19, 0x2, 0x1c2, 0x1c0, 0x3, 0x2, 0x2, 0x2, 0x1c2, 0x1c3, 0x3, 0x2, 
    0x2, 0x2, 0x1c3, 0x1c4, 0x3, 0x2, 0x2, 0x2, 0x1c4, 0x1c5, 0x8, 0x19, 
    0x1, 0x2, 0x1c5, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x1c6, 0x1c7, 0x7, 0x47, 
    0x2, 0x2, 0x1c7, 0x1c8, 0x5, 0x30, 0x19, 0x2, 0x1c8, 0x1c9, 0x7, 0x55, 
    0x2, 0x2, 0x1c9, 0x1ca, 0x7, 0x8, 0x2, 0x2, 0x1ca, 0x1cb, 0x5, 0x96, 
    0x4c, 0x2, 0x1cb, 0x1cc, 0x7, 0x9, 0x2, 0x2, 0x1cc, 0x1cd, 0x5, 0xd0, 
    0x69, 0x2, 0x1cd, 0x1ce, 0x8, 0x19, 0x1, 0x2, 0x1ce, 0x24e, 0x3, 0x2, 
    0x2, 0x2, 0x1cf, 0x1d0, 0x7, 0x55, 0x2, 0x2, 0x1d0, 0x1d1, 0x7, 0x8, 
    0x2, 0x2, 0x1d1, 0x1d2, 0x5, 0x96, 0x4c, 0x2, 0x1d2, 0x1d3, 0x7, 0x9, 
    0x2, 0x2, 0x1d3, 0x1d4, 0x5, 0x30, 0x19, 0x2, 0x1d4, 0x1d5, 0x8, 0x19, 
    0x1, 0x2, 0x1d5, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x1d6, 0x1d7, 0x7, 0x53, 
    0x2, 0x2, 0x1d7, 0x1d9, 0x7, 0x8, 0x2, 0x2, 0x1d8, 0x1da, 0x5, 0x48, 
    0x25, 0x2, 0x1d9, 0x1d8, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1da, 0x3, 0x2, 
    0x2, 0x2, 0x1da, 0x1db, 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dd, 0x7, 0xd, 
    0x2, 0x2, 0x1dc, 0x1de, 0x5, 0x96, 0x4c, 0x2, 0x1dd, 0x1dc, 0x3, 0x2, 
    0x2, 0x2, 0x1dd, 0x1de, 0x3, 0x2, 0x2, 0x2, 0x1de, 0x1df, 0x3, 0x2, 
    0x2, 0x2, 0x1df, 0x1e1, 0x7, 0xd, 0x2, 0x2, 0x1e0, 0x1e2, 0x5, 0x96, 
    0x4c, 0x2, 0x1e1, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1e1, 0x1e2, 0x3, 0x2, 
    0x2, 0x2, 0x1e2, 0x1e3, 0x3, 0x2, 0x2, 0x2, 0x1e3, 0x1e4, 0x7, 0x9, 
    0x2, 0x2, 0x1e4, 0x1e5, 0x5, 0x30, 0x19, 0x2, 0x1e5, 0x1e6, 0x8, 0x19, 
    0x1, 0x2, 0x1e6, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x1e7, 0x1e8, 0x7, 0x53, 
    0x2, 0x2, 0x1e8, 0x1e9, 0x7, 0x8, 0x2, 0x2, 0x1e9, 0x1ea, 0x5, 0x4a, 
    0x26, 0x2, 0x1ea, 0x1eb, 0x7, 0x5e, 0x2, 0x2, 0x1eb, 0x1ec, 0x5, 0x96, 
    0x4c, 0x2, 0x1ec, 0x1ed, 0x7, 0x9, 0x2, 0x2, 0x1ed, 0x1ee, 0x5, 0x30, 
    0x19, 0x2, 0x1ee, 0x1ef, 0x8, 0x19, 0x1, 0x2, 0x1ef, 0x24e, 0x3, 0x2, 
    0x2, 0x2, 0x1f0, 0x1f1, 0x7, 0x53, 0x2, 0x2, 0x1f1, 0x1f2, 0x7, 0x8, 
    0x2, 0x2, 0x1f2, 0x1f3, 0x5, 0x4a, 0x26, 0x2, 0x1f3, 0x1f4, 0x7, 0x5f, 
    0x2, 0x2, 0x1f4, 0x1f5, 0x5, 0x96, 0x4c, 0x2, 0x1f5, 0x1f6, 0x7, 0x9, 
    0x2, 0x2, 0x1f6, 0x1f7, 0x5, 0x30, 0x19, 0x2, 0x1f7, 0x1f8, 0x8, 0x19, 
    0x1, 0x2, 0x1f8, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x1f9, 0x1fc, 0x7, 0x52, 
    0x2, 0x2, 0x1fa, 0x1fb, 0x6, 0x19, 0x5, 0x2, 0x1fb, 0x1fd, 0x5, 0xb4, 
    0x5b, 0x2, 0x1fc, 0x1fa, 0x3, 0x2, 0x2, 0x2, 0x1fc, 0x1fd, 0x3, 0x2, 
    0x2, 0x2, 0x1fd, 0x1fe, 0x3, 0x2, 0x2, 0x2, 0x1fe, 0x1ff, 0x5, 0xd0, 
    0x69, 0x2, 0x1ff, 0x200, 0x8, 0x19, 0x1, 0x2, 0x200, 0x24e, 0x3, 0x2, 
    0x2, 0x2, 0x201, 0x204, 0x7, 0x46, 0x2, 0x2, 0x202, 0x203, 0x6, 0x19, 
    0x6, 0x2, 0x203, 0x205, 0x5, 0xb4, 0x5b, 0x2, 0x204, 0x202, 0x3, 0x2, 
    0x2, 0x2, 0x204, 0x205, 0x3, 0x2, 0x2, 0x2, 0x205, 0x206, 0x3, 0x2, 
    0x2, 0x2, 0x206, 0x207, 0x5, 0xd0, 0x69, 0x2, 0x207, 0x208, 0x8, 0x19, 
    0x1, 0x2, 0x208, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x209, 0x20a, 0x7, 0x50, 
    0x2, 0x2, 0x20a, 0x20b, 0x6, 0x19, 0x7, 0x2, 0x20b, 0x20c, 0x5, 0xb2, 
    0x5a, 0x2, 0x20c, 0x20d, 0x3, 0x2, 0x2, 0x2, 0x20d, 0x20e, 0x5, 0xd0, 
    0x69, 0x2, 0x20e, 0x20f, 0x8, 0x19, 0x1, 0x2, 0x20f, 0x24e, 0x3, 0x2, 
    0x2, 0x2, 0x210, 0x211, 0x7, 0x50, 0x2, 0x2, 0x211, 0x212, 0x5, 0xd0, 
    0x69, 0x2, 0x212, 0x213, 0x8, 0x19, 0x1, 0x2, 0x213, 0x24e, 0x3, 0x2, 
    0x2, 0x2, 0x214, 0x215, 0x7, 0x59, 0x2, 0x2, 0x215, 0x216, 0x7, 0x8, 
    0x2, 0x2, 0x216, 0x217, 0x5, 0x96, 0x4c, 0x2, 0x217, 0x218, 0x7, 0x9, 
    0x2, 0x2, 0x218, 0x219, 0x5, 0x30, 0x19, 0x2, 0x219, 0x21a, 0x8, 0x19, 
    0x1, 0x2, 0x21a, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x21b, 0x21c, 0x5, 0xb4, 
    0x5b, 0x2, 0x21c, 0x21d, 0x7, 0x11, 0x2, 0x2, 0x21d, 0x21e, 0x5, 0x30, 
    0x19, 0x2, 0x21e, 0x21f, 0x8, 0x19, 0x1, 0x2, 0x21f, 0x24e, 0x3, 0x2, 
    0x2, 0x2, 0x220, 0x221, 0x7, 0x54, 0x2, 0x2, 0x221, 0x222, 0x7, 0x8, 
    0x2, 0x2, 0x222, 0x223, 0x5, 0x96, 0x4c, 0x2, 0x223, 0x224, 0x7, 0x9, 
    0x2, 0x2, 0x224, 0x225, 0x5, 0x4e, 0x28, 0x2, 0x225, 0x226, 0x8, 0x19, 
    0x1, 0x2, 0x226, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x227, 0x228, 0x7, 0x5c, 
    0x2, 0x2, 0x228, 0x229, 0x6, 0x19, 0x8, 0x2, 0x229, 0x22a, 0x5, 0x96, 
    0x4c, 0x2, 0x22a, 0x22b, 0x5, 0xd0, 0x69, 0x2, 0x22b, 0x22c, 0x8, 0x19, 
    0x1, 0x2, 0x22c, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x22d, 0x22e, 0x7, 0x60, 
    0x2, 0x2, 0x22e, 0x230, 0x5, 0x32, 0x1a, 0x2, 0x22f, 0x231, 0x5, 0x56, 
    0x2c, 0x2, 0x230, 0x22f, 0x3, 0x2, 0x2, 0x2, 0x230, 0x231, 0x3, 0x2, 
    0x2, 0x2, 0x231, 0x233, 0x3, 0x2, 0x2, 0x2, 0x232, 0x234, 0x5, 0x58, 
    0x2d, 0x2, 0x233, 0x232, 0x3, 0x2, 0x2, 0x2, 0x233, 0x234, 0x3, 0x2, 
    0x2, 0x2, 0x234, 0x235, 0x3, 0x2, 0x2, 0x2, 0x235, 0x236, 0x8, 0x19, 
    0x1, 0x2, 0x236, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x237, 0x238, 0x7, 0x56, 
    0x2, 0x2, 0x238, 0x239, 0x5, 0xd0, 0x69, 0x2, 0x239, 0x23a, 0x8, 0x19, 
    0x1, 0x2, 0x23a, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x24e, 0x5, 0x34, 
    0x1b, 0x2, 0x23c, 0x23d, 0x7, 0x8e, 0x2, 0x2, 0x23d, 0x23e, 0x5, 0xb4, 
    0x5b, 0x2, 0x23e, 0x23f, 0x7, 0xf, 0x2, 0x2, 0x23f, 0x240, 0x5, 0xee, 
    0x78, 0x2, 0x240, 0x241, 0x5, 0xd0, 0x69, 0x2, 0x241, 0x242, 0x8, 0x19, 
    0x1, 0x2, 0x242, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x243, 0x244, 0x5, 0x22, 
    0x12, 0x2, 0x244, 0x245, 0x8, 0x19, 0x1, 0x2, 0x245, 0x24e, 0x3, 0x2, 
    0x2, 0x2, 0x246, 0x247, 0x6, 0x19, 0x9, 0x2, 0x247, 0x249, 0x5, 0x96, 
    0x4c, 0x2, 0x248, 0x24a, 0x7, 0xd, 0x2, 0x2, 0x249, 0x248, 0x3, 0x2, 
    0x2, 0x2, 0x249, 0x24a, 0x3, 0x2, 0x2, 0x2, 0x24a, 0x24b, 0x3, 0x2, 
    0x2, 0x2, 0x24b, 0x24c, 0x8, 0x19, 0x1, 0x2, 0x24c, 0x24e, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x199, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x19c, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x1a3, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x1ad, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x1af, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x1bb, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x1c6, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x1cf, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x1d6, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x1e7, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x1f9, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x201, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x209, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x210, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x214, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x220, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x227, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x22d, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x237, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x23b, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x23c, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x243, 0x3, 0x2, 
    0x2, 0x2, 0x24d, 0x246, 0x3, 0x2, 0x2, 0x2, 0x24e, 0x31, 0x3, 0x2, 0x2, 
    0x2, 0x24f, 0x251, 0x7, 0xa, 0x2, 0x2, 0x250, 0x252, 0x5, 0x3c, 0x1f, 
    0x2, 0x251, 0x250, 0x3, 0x2, 0x2, 0x2, 0x251, 0x252, 0x3, 0x2, 0x2, 
    0x2, 0x252, 0x253, 0x3, 0x2, 0x2, 0x2, 0x253, 0x254, 0x7, 0xc, 0x2, 
    0x2, 0x254, 0x255, 0x8, 0x1a, 0x1, 0x2, 0x255, 0x33, 0x3, 0x2, 0x2, 
    0x2, 0x256, 0x25c, 0x5, 0x36, 0x1c, 0x2, 0x257, 0x258, 0x5, 0x42, 0x22, 
    0x2, 0x258, 0x259, 0x5, 0xd0, 0x69, 0x2, 0x259, 0x25c, 0x3, 0x2, 0x2, 
    0x2, 0x25a, 0x25c, 0x5, 0x3a, 0x1e, 0x2, 0x25b, 0x256, 0x3, 0x2, 0x2, 
    0x2, 0x25b, 0x257, 0x3, 0x2, 0x2, 0x2, 0x25b, 0x25a, 0x3, 0x2, 0x2, 
    0x2, 0x25c, 0x35, 0x3, 0x2, 0x2, 0x2, 0x25d, 0x260, 0x5, 0x38, 0x1d, 
    0x2, 0x25e, 0x261, 0x5, 0x32, 0x1a, 0x2, 0x25f, 0x261, 0x7, 0xd, 0x2, 
    0x2, 0x260, 0x25e, 0x3, 0x2, 0x2, 0x2, 0x260, 0x25f, 0x3, 0x2, 0x2, 
    0x2, 0x260, 0x261, 0x3, 0x2, 0x2, 0x2, 0x261, 0x37, 0x3, 0x2, 0x2, 0x2, 
    0x262, 0x264, 0x7, 0x64, 0x2, 0x2, 0x263, 0x262, 0x3, 0x2, 0x2, 0x2, 
    0x263, 0x264, 0x3, 0x2, 0x2, 0x2, 0x264, 0x265, 0x3, 0x2, 0x2, 0x2, 
    0x265, 0x267, 0x7, 0x57, 0x2, 0x2, 0x266, 0x268, 0x7, 0x1a, 0x2, 0x2, 
    0x267, 0x266, 0x3, 0x2, 0x2, 0x2, 0x267, 0x268, 0x3, 0x2, 0x2, 0x2, 
    0x268, 0x26a, 0x3, 0x2, 0x2, 0x2, 0x269, 0x26b, 0x5, 0xb4, 0x5b, 0x2, 
    0x26a, 0x269, 0x3, 0x2, 0x2, 0x2, 0x26a, 0x26b, 0x3, 0x2, 0x2, 0x2, 
    0x26b, 0x26c, 0x3, 0x2, 0x2, 0x2, 0x26c, 0x26e, 0x7, 0x8, 0x2, 0x2, 
    0x26d, 0x26f, 0x5, 0xe, 0x8, 0x2, 0x26e, 0x26d, 0x3, 0x2, 0x2, 0x2, 
    0x26e, 0x26f, 0x3, 0x2, 0x2, 0x2, 0x26f, 0x270, 0x3, 0x2, 0x2, 0x2, 
    0x270, 0x273, 0x7, 0x9, 0x2, 0x2, 0x271, 0x272, 0x7, 0x11, 0x2, 0x2, 
    0x272, 0x274, 0x5, 0xf4, 0x7b, 0x2, 0x273, 0x271, 0x3, 0x2, 0x2, 0x2, 
    0x273, 0x274, 0x3, 0x2, 0x2, 0x2, 0x274, 0x275, 0x3, 0x2, 0x2, 0x2, 
    0x275, 0x276, 0x8, 0x1d, 0x1, 0x2, 0x276, 0x39, 0x3, 0x2, 0x2, 0x2, 
    0x277, 0x279, 0x7, 0x94, 0x2, 0x2, 0x278, 0x277, 0x3, 0x2, 0x2, 0x2, 
    0x278, 0x279, 0x3, 0x2, 0x2, 0x2, 0x279, 0x27b, 0x3, 0x2, 0x2, 0x2, 
    0x27a, 0x27c, 0x7, 0x95, 0x2, 0x2, 0x27b, 0x27a, 0x3, 0x2, 0x2, 0x2, 
    0x27b, 0x27c, 0x3, 0x2, 0x2, 0x2, 0x27c, 0x27d, 0x3, 0x2, 0x2, 0x2, 
    0x27d, 0x27f, 0x7, 0x65, 0x2, 0x2, 0x27e, 0x280, 0x5, 0xb4, 0x5b, 0x2, 
    0x27f, 0x27e, 0x3, 0x2, 0x2, 0x2, 0x27f, 0x280, 0x3, 0x2, 0x2, 0x2, 
    0x280, 0x282, 0x3, 0x2, 0x2, 0x2, 0x281, 0x283, 0x5, 0x5c, 0x2f, 0x2, 
    0x282, 0x281, 0x3, 0x2, 0x2, 0x2, 0x282, 0x283, 0x3, 0x2, 0x2, 0x2, 
    0x283, 0x285, 0x3, 0x2, 0x2, 0x2, 0x284, 0x286, 0x5, 0x5e, 0x30, 0x2, 
    0x285, 0x284, 0x3, 0x2, 0x2, 0x2, 0x285, 0x286, 0x3, 0x2, 0x2, 0x2, 
    0x286, 0x287, 0x3, 0x2, 0x2, 0x2, 0x287, 0x288, 0x5, 0x5a, 0x2e, 0x2, 
    0x288, 0x289, 0x8, 0x1e, 0x1, 0x2, 0x289, 0x3b, 0x3, 0x2, 0x2, 0x2, 
    0x28a, 0x28c, 0x5, 0x30, 0x19, 0x2, 0x28b, 0x28a, 0x3, 0x2, 0x2, 0x2, 
    0x28c, 0x28d, 0x3, 0x2, 0x2, 0x2, 0x28d, 0x28b, 0x3, 0x2, 0x2, 0x2, 
    0x28d, 0x28e, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x28f, 
    0x292, 0x7, 0x1a, 0x2, 0x2, 0x290, 0x292, 0x5, 0x40, 0x21, 0x2, 0x291, 
    0x28f, 0x3, 0x2, 0x2, 0x2, 0x291, 0x290, 0x3, 0x2, 0x2, 0x2, 0x292, 
    0x295, 0x3, 0x2, 0x2, 0x2, 0x293, 0x294, 0x7, 0x61, 0x2, 0x2, 0x294, 
    0x296, 0x5, 0xb4, 0x5b, 0x2, 0x295, 0x293, 0x3, 0x2, 0x2, 0x2, 0x295, 
    0x296, 0x3, 0x2, 0x2, 0x2, 0x296, 0x297, 0x3, 0x2, 0x2, 0x2, 0x297, 
    0x298, 0x7, 0x62, 0x2, 0x2, 0x298, 0x299, 0x7, 0x9c, 0x2, 0x2, 0x299, 
    0x29a, 0x5, 0xd0, 0x69, 0x2, 0x29a, 0x3f, 0x3, 0x2, 0x2, 0x2, 0x29b, 
    0x29c, 0x5, 0xb4, 0x5b, 0x2, 0x29c, 0x29d, 0x7, 0xe, 0x2, 0x2, 0x29d, 
    0x29f, 0x3, 0x2, 0x2, 0x2, 0x29e, 0x29b, 0x3, 0x2, 0x2, 0x2, 0x29e, 
    0x29f, 0x3, 0x2, 0x2, 0x2, 0x29f, 0x2a0, 0x3, 0x2, 0x2, 0x2, 0x2a0, 
    0x2a1, 0x7, 0xa, 0x2, 0x2, 0x2a1, 0x2a6, 0x5, 0xb4, 0x5b, 0x2, 0x2a2, 
    0x2a3, 0x7, 0xe, 0x2, 0x2, 0x2a3, 0x2a5, 0x5, 0xb4, 0x5b, 0x2, 0x2a4, 
    0x2a2, 0x3, 0x2, 0x2, 0x2, 0x2a5, 0x2a8, 0x3, 0x2, 0x2, 0x2, 0x2a6, 
    0x2a4, 0x3, 0x2, 0x2, 0x2, 0x2a6, 0x2a7, 0x3, 0x2, 0x2, 0x2, 0x2a7, 
    0x2a9, 0x3, 0x2, 0x2, 0x2, 0x2a8, 0x2a6, 0x3, 0x2, 0x2, 0x2, 0x2a9, 
    0x2aa, 0x7, 0xc, 0x2, 0x2, 0x2aa, 0x41, 0x3, 0x2, 0x2, 0x2, 0x2ab, 0x2ac, 
    0x5, 0x4c, 0x27, 0x2, 0x2ac, 0x2ae, 0x5, 0x44, 0x23, 0x2, 0x2ad, 0x2af, 
    0x7, 0xd, 0x2, 0x2, 0x2ae, 0x2ad, 0x3, 0x2, 0x2, 0x2, 0x2ae, 0x2af, 
    0x3, 0x2, 0x2, 0x2, 0x2af, 0x2b0, 0x3, 0x2, 0x2, 0x2, 0x2b0, 0x2b1, 
    0x8, 0x22, 0x1, 0x2, 0x2b1, 0x2b7, 0x3, 0x2, 0x2, 0x2, 0x2b2, 0x2b3, 
    0x7, 0x6d, 0x2, 0x2, 0x2b3, 0x2b4, 0x5, 0xd0, 0x69, 0x2, 0x2b4, 0x2b5, 
    0x8, 0x22, 0x1, 0x2, 0x2b5, 0x2b7, 0x3, 0x2, 0x2, 0x2, 0x2b6, 0x2ab, 
    0x3, 0x2, 0x2, 0x2, 0x2b6, 0x2b2, 0x3, 0x2, 0x2, 0x2, 0x2b7, 0x43, 0x3, 
    0x2, 0x2, 0x2, 0x2b8, 0x2bd, 0x5, 0x46, 0x24, 0x2, 0x2b9, 0x2ba, 0x7, 
    0xe, 0x2, 0x2, 0x2ba, 0x2bc, 0x5, 0x46, 0x24, 0x2, 0x2bb, 0x2b9, 0x3, 
    0x2, 0x2, 0x2, 0x2bc, 0x2bf, 0x3, 0x2, 0x2, 0x2, 0x2bd, 0x2bb, 0x3, 
    0x2, 0x2, 0x2, 0x2bd, 0x2be, 0x3, 0x2, 0x2, 0x2, 0x2be, 0x45, 0x3, 0x2, 
    0x2, 0x2, 0x2bf, 0x2bd, 0x3, 0x2, 0x2, 0x2, 0x2c0, 0x2c3, 0x5, 0x8, 
    0x5, 0x2, 0x2c1, 0x2c2, 0x7, 0xf, 0x2, 0x2, 0x2c2, 0x2c4, 0x5, 0xb2, 
    0x5a, 0x2, 0x2c3, 0x2c1, 0x3, 0x2, 0x2, 0x2, 0x2c3, 0x2c4, 0x3, 0x2, 
    0x2, 0x2, 0x2c4, 0x2c5, 0x3, 0x2, 0x2, 0x2, 0x2c5, 0x2c6, 0x8, 0x24, 
    0x1, 0x2, 0x2c6, 0x2cd, 0x3, 0x2, 0x2, 0x2, 0x2c7, 0x2c8, 0x5, 0x8, 
    0x5, 0x2, 0x2c8, 0x2c9, 0x7, 0xf, 0x2, 0x2, 0x2c9, 0x2ca, 0x5, 0xca, 
    0x66, 0x2, 0x2ca, 0x2cb, 0x8, 0x24, 0x1, 0x2, 0x2cb, 0x2cd, 0x3, 0x2, 
    0x2, 0x2, 0x2cc, 0x2c0, 0x3, 0x2, 0x2, 0x2, 0x2cc, 0x2c7, 0x3, 0x2, 
    0x2, 0x2, 0x2cd, 0x47, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2d1, 0x5, 0x42, 
    0x22, 0x2, 0x2cf, 0x2d1, 0x5, 0xb2, 0x5a, 0x2, 0x2d0, 0x2ce, 0x3, 0x2, 
    0x2, 0x2, 0x2d0, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0x2d1, 0x49, 0x3, 0x2, 0x2, 
    0x2, 0x2d2, 0x2d8, 0x5, 0x42, 0x22, 0x2, 0x2d3, 0x2d8, 0x5, 0x8, 0x5, 
    0x2, 0x2d4, 0x2d5, 0x5, 0xb2, 0x5a, 0x2, 0x2d5, 0x2d6, 0x8, 0x26, 0x1, 
    0x2, 0x2d6, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0x2d7, 0x2d2, 0x3, 0x2, 0x2, 
    0x2, 0x2d7, 0x2d3, 0x3, 0x2, 0x2, 0x2, 0x2d7, 0x2d4, 0x3, 0x2, 0x2, 
    0x2, 0x2d8, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x2d9, 0x2da, 0x9, 0x2, 0x2, 0x2, 
    0x2da, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2db, 0x2dd, 0x7, 0xa, 0x2, 0x2, 0x2dc, 
    0x2de, 0x5, 0x50, 0x29, 0x2, 0x2dd, 0x2dc, 0x3, 0x2, 0x2, 0x2, 0x2dd, 
    0x2de, 0x3, 0x2, 0x2, 0x2, 0x2de, 0x2e3, 0x3, 0x2, 0x2, 0x2, 0x2df, 
    0x2e1, 0x5, 0x54, 0x2b, 0x2, 0x2e0, 0x2e2, 0x5, 0x50, 0x29, 0x2, 0x2e1, 
    0x2e0, 0x3, 0x2, 0x2, 0x2, 0x2e1, 0x2e2, 0x3, 0x2, 0x2, 0x2, 0x2e2, 
    0x2e4, 0x3, 0x2, 0x2, 0x2, 0x2e3, 0x2df, 0x3, 0x2, 0x2, 0x2, 0x2e3, 
    0x2e4, 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2e5, 0x3, 0x2, 0x2, 0x2, 0x2e5, 
    0x2e6, 0x7, 0xc, 0x2, 0x2, 0x2e6, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x2e7, 0x2e9, 
    0x5, 0x52, 0x2a, 0x2, 0x2e8, 0x2e7, 0x3, 0x2, 0x2, 0x2, 0x2e9, 0x2ea, 
    0x3, 0x2, 0x2, 0x2, 0x2ea, 0x2e8, 0x3, 0x2, 0x2, 0x2, 0x2ea, 0x2eb, 
    0x3, 0x2, 0x2, 0x2, 0x2eb, 0x51, 0x3, 0x2, 0x2, 0x2, 0x2ec, 0x2ed, 0x7, 
    0x4a, 0x2, 0x2, 0x2ed, 0x2ee, 0x5, 0x96, 0x4c, 0x2, 0x2ee, 0x2f0, 0x7, 
    0x11, 0x2, 0x2, 0x2ef, 0x2f1, 0x5, 0x3c, 0x1f, 0x2, 0x2f0, 0x2ef, 0x3, 
    0x2, 0x2, 0x2, 0x2f0, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2f1, 0x2f2, 0x3, 
    0x2, 0x2, 0x2, 0x2f2, 0x2f3, 0x8, 0x2a, 0x1, 0x2, 0x2f3, 0x53, 0x3, 
    0x2, 0x2, 0x2, 0x2f4, 0x2f5, 0x7, 0x5a, 0x2, 0x2, 0x2f5, 0x2f7, 0x7, 
    0x11, 0x2, 0x2, 0x2f6, 0x2f8, 0x5, 0x3c, 0x1f, 0x2, 0x2f7, 0x2f6, 0x3, 
    0x2, 0x2, 0x2, 0x2f7, 0x2f8, 0x3, 0x2, 0x2, 0x2, 0x2f8, 0x2f9, 0x3, 
    0x2, 0x2, 0x2, 0x2f9, 0x2fa, 0x8, 0x2b, 0x1, 0x2, 0x2fa, 0x55, 0x3, 
    0x2, 0x2, 0x2, 0x2fb, 0x2fc, 0x7, 0x4e, 0x2, 0x2, 0x2fc, 0x2fd, 0x7, 
    0x8, 0x2, 0x2, 0x2fd, 0x2fe, 0x5, 0xb4, 0x5b, 0x2, 0x2fe, 0x2ff, 0x7, 
    0x9, 0x2, 0x2, 0x2ff, 0x300, 0x5, 0x32, 0x1a, 0x2, 0x300, 0x301, 0x8, 
    0x2c, 0x1, 0x2, 0x301, 0x57, 0x3, 0x2, 0x2, 0x2, 0x302, 0x303, 0x7, 
    0x4f, 0x2, 0x2, 0x303, 0x304, 0x5, 0x32, 0x1a, 0x2, 0x304, 0x59, 0x3, 
    0x2, 0x2, 0x2, 0x305, 0x309, 0x7, 0xa, 0x2, 0x2, 0x306, 0x308, 0x5, 
    0x60, 0x31, 0x2, 0x307, 0x306, 0x3, 0x2, 0x2, 0x2, 0x308, 0x30b, 0x3, 
    0x2, 0x2, 0x2, 0x309, 0x307, 0x3, 0x2, 0x2, 0x2, 0x309, 0x30a, 0x3, 
    0x2, 0x2, 0x2, 0x30a, 0x30c, 0x3, 0x2, 0x2, 0x2, 0x30b, 0x309, 0x3, 
    0x2, 0x2, 0x2, 0x30c, 0x30d, 0x7, 0xc, 0x2, 0x2, 0x30d, 0x5b, 0x3, 0x2, 
    0x2, 0x2, 0x30e, 0x30f, 0x7, 0x67, 0x2, 0x2, 0x30f, 0x310, 0x5, 0xd8, 
    0x6d, 0x2, 0x310, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x311, 0x312, 0x7, 0x6c, 
    0x2, 0x2, 0x312, 0x313, 0x5, 0x20, 0x11, 0x2, 0x313, 0x5f, 0x3, 0x2, 
    0x2, 0x2, 0x314, 0x317, 0x5, 0x62, 0x32, 0x2, 0x315, 0x317, 0x5, 0x64, 
    0x33, 0x2, 0x316, 0x314, 0x3, 0x2, 0x2, 0x2, 0x316, 0x315, 0x3, 0x2, 
    0x2, 0x2, 0x317, 0x61, 0x3, 0x2, 0x2, 0x2, 0x318, 0x31a, 0x5, 0x1c, 
    0xf, 0x2, 0x319, 0x318, 0x3, 0x2, 0x2, 0x2, 0x319, 0x31a, 0x3, 0x2, 
    0x2, 0x2, 0x31a, 0x31c, 0x3, 0x2, 0x2, 0x2, 0x31b, 0x31d, 0x7, 0x73, 
    0x2, 0x2, 0x31c, 0x31b, 0x3, 0x2, 0x2, 0x2, 0x31c, 0x31d, 0x3, 0x2, 
    0x2, 0x2, 0x31d, 0x31f, 0x3, 0x2, 0x2, 0x2, 0x31e, 0x320, 0x7, 0x64, 
    0x2, 0x2, 0x31f, 0x31e, 0x3, 0x2, 0x2, 0x2, 0x31f, 0x320, 0x3, 0x2, 
    0x2, 0x2, 0x320, 0x321, 0x3, 0x2, 0x2, 0x2, 0x321, 0x322, 0x5, 0x82, 
    0x42, 0x2, 0x322, 0x324, 0x7, 0x8, 0x2, 0x2, 0x323, 0x325, 0x5, 0x12, 
    0xa, 0x2, 0x324, 0x323, 0x3, 0x2, 0x2, 0x2, 0x324, 0x325, 0x3, 0x2, 
    0x2, 0x2, 0x325, 0x326, 0x3, 0x2, 0x2, 0x2, 0x326, 0x329, 0x7, 0x9, 
    0x2, 0x2, 0x327, 0x32a, 0x5, 0x32, 0x1a, 0x2, 0x328, 0x32a, 0x7, 0xd, 
    0x2, 0x2, 0x329, 0x327, 0x3, 0x2, 0x2, 0x2, 0x329, 0x328, 0x3, 0x2, 
    0x2, 0x2, 0x32a, 0x32b, 0x3, 0x2, 0x2, 0x2, 0x32b, 0x32c, 0x8, 0x32, 
    0x1, 0x2, 0x32c, 0x349, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x32f, 0x5, 0x1c, 
    0xf, 0x2, 0x32e, 0x32d, 0x3, 0x2, 0x2, 0x2, 0x32e, 0x32f, 0x3, 0x2, 
    0x2, 0x2, 0x32f, 0x331, 0x3, 0x2, 0x2, 0x2, 0x330, 0x332, 0x7, 0x73, 
    0x2, 0x2, 0x331, 0x330, 0x3, 0x2, 0x2, 0x2, 0x331, 0x332, 0x3, 0x2, 
    0x2, 0x2, 0x332, 0x334, 0x3, 0x2, 0x2, 0x2, 0x333, 0x335, 0x7, 0x64, 
    0x2, 0x2, 0x334, 0x333, 0x3, 0x2, 0x2, 0x2, 0x334, 0x335, 0x3, 0x2, 
    0x2, 0x2, 0x335, 0x338, 0x3, 0x2, 0x2, 0x2, 0x336, 0x339, 0x5, 0x8e, 
    0x48, 0x2, 0x337, 0x339, 0x5, 0x90, 0x49, 0x2, 0x338, 0x336, 0x3, 0x2, 
    0x2, 0x2, 0x338, 0x337, 0x3, 0x2, 0x2, 0x2, 0x339, 0x33a, 0x3, 0x2, 
    0x2, 0x2, 0x33a, 0x33b, 0x8, 0x32, 0x1, 0x2, 0x33b, 0x349, 0x3, 0x2, 
    0x2, 0x2, 0x33c, 0x33e, 0x5, 0x1c, 0xf, 0x2, 0x33d, 0x33c, 0x3, 0x2, 
    0x2, 0x2, 0x33d, 0x33e, 0x3, 0x2, 0x2, 0x2, 0x33e, 0x33f, 0x3, 0x2, 
    0x2, 0x2, 0x33f, 0x340, 0x7, 0x91, 0x2, 0x2, 0x340, 0x342, 0x7, 0x8, 
    0x2, 0x2, 0x341, 0x343, 0x5, 0x12, 0xa, 0x2, 0x342, 0x341, 0x3, 0x2, 
    0x2, 0x2, 0x342, 0x343, 0x3, 0x2, 0x2, 0x2, 0x343, 0x344, 0x3, 0x2, 
    0x2, 0x2, 0x344, 0x345, 0x7, 0x9, 0x2, 0x2, 0x345, 0x346, 0x5, 0x32, 
    0x1a, 0x2, 0x346, 0x347, 0x8, 0x32, 0x1, 0x2, 0x347, 0x349, 0x3, 0x2, 
    0x2, 0x2, 0x348, 0x319, 0x3, 0x2, 0x2, 0x2, 0x348, 0x32e, 0x3, 0x2, 
    0x2, 0x2, 0x348, 0x33d, 0x3, 0x2, 0x2, 0x2, 0x349, 0x63, 0x3, 0x2, 0x2, 
    0x2, 0x34a, 0x34c, 0x5, 0x1c, 0xf, 0x2, 0x34b, 0x34a, 0x3, 0x2, 0x2, 
    0x2, 0x34b, 0x34c, 0x3, 0x2, 0x2, 0x2, 0x34c, 0x34e, 0x3, 0x2, 0x2, 
    0x2, 0x34d, 0x34f, 0x7, 0x73, 0x2, 0x2, 0x34e, 0x34d, 0x3, 0x2, 0x2, 
    0x2, 0x34e, 0x34f, 0x3, 0x2, 0x2, 0x2, 0x34f, 0x351, 0x3, 0x2, 0x2, 
    0x2, 0x350, 0x352, 0x7, 0x63, 0x2, 0x2, 0x351, 0x350, 0x3, 0x2, 0x2, 
    0x2, 0x351, 0x352, 0x3, 0x2, 0x2, 0x2, 0x352, 0x353, 0x3, 0x2, 0x2, 
    0x2, 0x353, 0x355, 0x5, 0x82, 0x42, 0x2, 0x354, 0x356, 0x7, 0x10, 0x2, 
    0x2, 0x355, 0x354, 0x3, 0x2, 0x2, 0x2, 0x355, 0x356, 0x3, 0x2, 0x2, 
    0x2, 0x356, 0x358, 0x3, 0x2, 0x2, 0x2, 0x357, 0x359, 0x5, 0xd4, 0x6b, 
    0x2, 0x358, 0x357, 0x3, 0x2, 0x2, 0x2, 0x358, 0x359, 0x3, 0x2, 0x2, 
    0x2, 0x359, 0x35b, 0x3, 0x2, 0x2, 0x2, 0x35a, 0x35c, 0x5, 0xb2, 0x5a, 
    0x2, 0x35b, 0x35a, 0x3, 0x2, 0x2, 0x2, 0x35b, 0x35c, 0x3, 0x2, 0x2, 
    0x2, 0x35c, 0x35d, 0x3, 0x2, 0x2, 0x2, 0x35d, 0x35e, 0x7, 0xd, 0x2, 
    0x2, 0x35e, 0x35f, 0x8, 0x33, 0x1, 0x2, 0x35f, 0x65, 0x3, 0x2, 0x2, 
    0x2, 0x360, 0x362, 0x7, 0x1a, 0x2, 0x2, 0x361, 0x360, 0x3, 0x2, 0x2, 
    0x2, 0x361, 0x362, 0x3, 0x2, 0x2, 0x2, 0x362, 0x363, 0x3, 0x2, 0x2, 
    0x2, 0x363, 0x364, 0x5, 0xb4, 0x5b, 0x2, 0x364, 0x366, 0x7, 0x8, 0x2, 
    0x2, 0x365, 0x367, 0x5, 0xe, 0x8, 0x2, 0x366, 0x365, 0x3, 0x2, 0x2, 
    0x2, 0x366, 0x367, 0x3, 0x2, 0x2, 0x2, 0x367, 0x368, 0x3, 0x2, 0x2, 
    0x2, 0x368, 0x369, 0x7, 0x9, 0x2, 0x2, 0x369, 0x36a, 0x7, 0xa, 0x2, 
    0x2, 0x36a, 0x36b, 0x5, 0x72, 0x3a, 0x2, 0x36b, 0x36c, 0x7, 0xc, 0x2, 
    0x2, 0x36c, 0x67, 0x3, 0x2, 0x2, 0x2, 0x36d, 0x36e, 0x7, 0x57, 0x2, 
    0x2, 0x36e, 0x370, 0x7, 0x1a, 0x2, 0x2, 0x36f, 0x371, 0x5, 0xb4, 0x5b, 
    0x2, 0x370, 0x36f, 0x3, 0x2, 0x2, 0x2, 0x370, 0x371, 0x3, 0x2, 0x2, 
    0x2, 0x371, 0x372, 0x3, 0x2, 0x2, 0x2, 0x372, 0x374, 0x7, 0x8, 0x2, 
    0x2, 0x373, 0x375, 0x5, 0xe, 0x8, 0x2, 0x374, 0x373, 0x3, 0x2, 0x2, 
    0x2, 0x374, 0x375, 0x3, 0x2, 0x2, 0x2, 0x375, 0x376, 0x3, 0x2, 0x2, 
    0x2, 0x376, 0x377, 0x7, 0x9, 0x2, 0x2, 0x377, 0x378, 0x7, 0xa, 0x2, 
    0x2, 0x378, 0x379, 0x5, 0x72, 0x3a, 0x2, 0x379, 0x37a, 0x7, 0xc, 0x2, 
    0x2, 0x37a, 0x69, 0x3, 0x2, 0x2, 0x2, 0x37b, 0x37c, 0x7, 0xa, 0x2, 0x2, 
    0x37c, 0x381, 0x5, 0x6c, 0x37, 0x2, 0x37d, 0x37e, 0x7, 0xe, 0x2, 0x2, 
    0x37e, 0x380, 0x5, 0x6c, 0x37, 0x2, 0x37f, 0x37d, 0x3, 0x2, 0x2, 0x2, 
    0x380, 0x383, 0x3, 0x2, 0x2, 0x2, 0x381, 0x37f, 0x3, 0x2, 0x2, 0x2, 
    0x381, 0x382, 0x3, 0x2, 0x2, 0x2, 0x382, 0x385, 0x3, 0x2, 0x2, 0x2, 
    0x383, 0x381, 0x3, 0x2, 0x2, 0x2, 0x384, 0x386, 0x7, 0xe, 0x2, 0x2, 
    0x385, 0x384, 0x3, 0x2, 0x2, 0x2, 0x385, 0x386, 0x3, 0x2, 0x2, 0x2, 
    0x386, 0x387, 0x3, 0x2, 0x2, 0x2, 0x387, 0x388, 0x7, 0xc, 0x2, 0x2, 
    0x388, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x389, 0x38a, 0x7, 0x1a, 0x2, 0x2, 
    0x38a, 0x38b, 0x5, 0x70, 0x39, 0x2, 0x38b, 0x6d, 0x3, 0x2, 0x2, 0x2, 
    0x38c, 0x38d, 0x7, 0xa, 0x2, 0x2, 0x38d, 0x392, 0x5, 0x70, 0x39, 0x2, 
    0x38e, 0x38f, 0x7, 0xe, 0x2, 0x2, 0x38f, 0x391, 0x5, 0x70, 0x39, 0x2, 
    0x390, 0x38e, 0x3, 0x2, 0x2, 0x2, 0x391, 0x394, 0x3, 0x2, 0x2, 0x2, 
    0x392, 0x390, 0x3, 0x2, 0x2, 0x2, 0x392, 0x393, 0x3, 0x2, 0x2, 0x2, 
    0x393, 0x396, 0x3, 0x2, 0x2, 0x2, 0x394, 0x392, 0x3, 0x2, 0x2, 0x2, 
    0x395, 0x397, 0x7, 0xe, 0x2, 0x2, 0x396, 0x395, 0x3, 0x2, 0x2, 0x2, 
    0x396, 0x397, 0x3, 0x2, 0x2, 0x2, 0x397, 0x398, 0x3, 0x2, 0x2, 0x2, 
    0x398, 0x399, 0x7, 0xc, 0x2, 0x2, 0x399, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x39a, 
    0x39b, 0x7, 0x6, 0x2, 0x2, 0x39b, 0x39c, 0x5, 0xb2, 0x5a, 0x2, 0x39c, 
    0x39d, 0x7, 0x7, 0x2, 0x2, 0x39d, 0x39f, 0x7, 0x8, 0x2, 0x2, 0x39e, 
    0x3a0, 0x5, 0xe, 0x8, 0x2, 0x39f, 0x39e, 0x3, 0x2, 0x2, 0x2, 0x39f, 
    0x3a0, 0x3, 0x2, 0x2, 0x2, 0x3a0, 0x3a1, 0x3, 0x2, 0x2, 0x2, 0x3a1, 
    0x3a2, 0x7, 0x9, 0x2, 0x2, 0x3a2, 0x3a3, 0x7, 0xa, 0x2, 0x2, 0x3a3, 
    0x3a4, 0x5, 0x72, 0x3a, 0x2, 0x3a4, 0x3a5, 0x7, 0xc, 0x2, 0x2, 0x3a5, 
    0x71, 0x3, 0x2, 0x2, 0x2, 0x3a6, 0x3a8, 0x5, 0x74, 0x3b, 0x2, 0x3a7, 
    0x3a6, 0x3, 0x2, 0x2, 0x2, 0x3a7, 0x3a8, 0x3, 0x2, 0x2, 0x2, 0x3a8, 
    0x73, 0x3, 0x2, 0x2, 0x2, 0x3a9, 0x3ab, 0x5, 0x2e, 0x18, 0x2, 0x3aa, 
    0x3a9, 0x3, 0x2, 0x2, 0x2, 0x3ab, 0x3ac, 0x3, 0x2, 0x2, 0x2, 0x3ac, 
    0x3aa, 0x3, 0x2, 0x2, 0x2, 0x3ac, 0x3ad, 0x3, 0x2, 0x2, 0x2, 0x3ad, 
    0x75, 0x3, 0x2, 0x2, 0x2, 0x3ae, 0x3af, 0x7, 0x12, 0x2, 0x2, 0x3af, 
    0x3b0, 0x5, 0xb2, 0x5a, 0x2, 0x3b0, 0x3b1, 0x8, 0x3c, 0x1, 0x2, 0x3b1, 
    0x77, 0x3, 0x2, 0x2, 0x2, 0x3b2, 0x3b5, 0x5, 0x76, 0x3c, 0x2, 0x3b3, 
    0x3b5, 0x5, 0xb2, 0x5a, 0x2, 0x3b4, 0x3b2, 0x3, 0x2, 0x2, 0x2, 0x3b4, 
    0x3b3, 0x3, 0x2, 0x2, 0x2, 0x3b5, 0x79, 0x3, 0x2, 0x2, 0x2, 0x3b6, 0x3b8, 
    0x7, 0xe, 0x2, 0x2, 0x3b7, 0x3b6, 0x3, 0x2, 0x2, 0x2, 0x3b8, 0x3bb, 
    0x3, 0x2, 0x2, 0x2, 0x3b9, 0x3b7, 0x3, 0x2, 0x2, 0x2, 0x3b9, 0x3ba, 
    0x3, 0x2, 0x2, 0x2, 0x3ba, 0x3be, 0x3, 0x2, 0x2, 0x2, 0x3bb, 0x3b9, 
    0x3, 0x2, 0x2, 0x2, 0x3bc, 0x3bf, 0x5, 0x78, 0x3d, 0x2, 0x3bd, 0x3bf, 
    0x7, 0xe, 0x2, 0x2, 0x3be, 0x3bc, 0x3, 0x2, 0x2, 0x2, 0x3be, 0x3bd, 
    0x3, 0x2, 0x2, 0x2, 0x3bf, 0x3c8, 0x3, 0x2, 0x2, 0x2, 0x3c0, 0x3c2, 
    0x7, 0xe, 0x2, 0x2, 0x3c1, 0x3c0, 0x3, 0x2, 0x2, 0x2, 0x3c2, 0x3c3, 
    0x3, 0x2, 0x2, 0x2, 0x3c3, 0x3c1, 0x3, 0x2, 0x2, 0x2, 0x3c3, 0x3c4, 
    0x3, 0x2, 0x2, 0x2, 0x3c4, 0x3c5, 0x3, 0x2, 0x2, 0x2, 0x3c5, 0x3c7, 
    0x5, 0x78, 0x3d, 0x2, 0x3c6, 0x3c1, 0x3, 0x2, 0x2, 0x2, 0x3c7, 0x3ca, 
    0x3, 0x2, 0x2, 0x2, 0x3c8, 0x3c6, 0x3, 0x2, 0x2, 0x2, 0x3c8, 0x3c9, 
    0x3, 0x2, 0x2, 0x2, 0x3c9, 0x3ce, 0x3, 0x2, 0x2, 0x2, 0x3ca, 0x3c8, 
    0x3, 0x2, 0x2, 0x2, 0x3cb, 0x3cd, 0x7, 0xe, 0x2, 0x2, 0x3cc, 0x3cb, 
    0x3, 0x2, 0x2, 0x2, 0x3cd, 0x3d0, 0x3, 0x2, 0x2, 0x2, 0x3ce, 0x3cc, 
    0x3, 0x2, 0x2, 0x2, 0x3ce, 0x3cf, 0x3, 0x2, 0x2, 0x2, 0x3cf, 0x7b, 0x3, 
    0x2, 0x2, 0x2, 0x3d0, 0x3ce, 0x3, 0x2, 0x2, 0x2, 0x3d1, 0x3d3, 0x7, 
    0xe, 0x2, 0x2, 0x3d2, 0x3d1, 0x3, 0x2, 0x2, 0x2, 0x3d3, 0x3d6, 0x3, 
    0x2, 0x2, 0x2, 0x3d4, 0x3d2, 0x3, 0x2, 0x2, 0x2, 0x3d4, 0x3d5, 0x3, 
    0x2, 0x2, 0x2, 0x3d5, 0x3da, 0x3, 0x2, 0x2, 0x2, 0x3d6, 0x3d4, 0x3, 
    0x2, 0x2, 0x2, 0x3d7, 0x3db, 0x5, 0x8, 0x5, 0x2, 0x3d8, 0x3db, 0x5, 
    0xa, 0x6, 0x2, 0x3d9, 0x3db, 0x7, 0xe, 0x2, 0x2, 0x3da, 0x3d7, 0x3, 
    0x2, 0x2, 0x2, 0x3da, 0x3d8, 0x3, 0x2, 0x2, 0x2, 0x3da, 0x3d9, 0x3, 
    0x2, 0x2, 0x2, 0x3db, 0x3e7, 0x3, 0x2, 0x2, 0x2, 0x3dc, 0x3de, 0x7, 
    0xe, 0x2, 0x2, 0x3dd, 0x3dc, 0x3, 0x2, 0x2, 0x2, 0x3de, 0x3df, 0x3, 
    0x2, 0x2, 0x2, 0x3df, 0x3dd, 0x3, 0x2, 0x2, 0x2, 0x3df, 0x3e0, 0x3, 
    0x2, 0x2, 0x2, 0x3e0, 0x3e3, 0x3, 0x2, 0x2, 0x2, 0x3e1, 0x3e4, 0x5, 
    0x8, 0x5, 0x2, 0x3e2, 0x3e4, 0x5, 0xa, 0x6, 0x2, 0x3e3, 0x3e1, 0x3, 
    0x2, 0x2, 0x2, 0x3e3, 0x3e2, 0x3, 0x2, 0x2, 0x2, 0x3e4, 0x3e6, 0x3, 
    0x2, 0x2, 0x2, 0x3e5, 0x3dd, 0x3, 0x2, 0x2, 0x2, 0x3e6, 0x3e9, 0x3, 
    0x2, 0x2, 0x2, 0x3e7, 0x3e5, 0x3, 0x2, 0x2, 0x2, 0x3e7, 0x3e8, 0x3, 
    0x2, 0x2, 0x2, 0x3e8, 0x3ed, 0x3, 0x2, 0x2, 0x2, 0x3e9, 0x3e7, 0x3, 
    0x2, 0x2, 0x2, 0x3ea, 0x3ec, 0x7, 0xe, 0x2, 0x2, 0x3eb, 0x3ea, 0x3, 
    0x2, 0x2, 0x2, 0x3ec, 0x3ef, 0x3, 0x2, 0x2, 0x2, 0x3ed, 0x3eb, 0x3, 
    0x2, 0x2, 0x2, 0x3ed, 0x3ee, 0x3, 0x2, 0x2, 0x2, 0x3ee, 0x7d, 0x3, 0x2, 
    0x2, 0x2, 0x3ef, 0x3ed, 0x3, 0x2, 0x2, 0x2, 0x3f0, 0x3f3, 0x5, 0x86, 
    0x44, 0x2, 0x3f1, 0x3f3, 0x5, 0x76, 0x3c, 0x2, 0x3f2, 0x3f0, 0x3, 0x2, 
    0x2, 0x2, 0x3f2, 0x3f1, 0x3, 0x2, 0x2, 0x2, 0x3f3, 0x7f, 0x3, 0x2, 0x2, 
    0x2, 0x3f4, 0x3f9, 0x5, 0x7e, 0x40, 0x2, 0x3f5, 0x3f6, 0x7, 0xe, 0x2, 
    0x2, 0x3f6, 0x3f8, 0x5, 0x7e, 0x40, 0x2, 0x3f7, 0x3f5, 0x3, 0x2, 0x2, 
    0x2, 0x3f8, 0x3fb, 0x3, 0x2, 0x2, 0x2, 0x3f9, 0x3f7, 0x3, 0x2, 0x2, 
    0x2, 0x3f9, 0x3fa, 0x3, 0x2, 0x2, 0x2, 0x3fa, 0x3fd, 0x3, 0x2, 0x2, 
    0x2, 0x3fb, 0x3f9, 0x3, 0x2, 0x2, 0x2, 0x3fc, 0x3fe, 0x7, 0xe, 0x2, 
    0x2, 0x3fd, 0x3fc, 0x3, 0x2, 0x2, 0x2, 0x3fd, 0x3fe, 0x3, 0x2, 0x2, 
    0x2, 0x3fe, 0x81, 0x3, 0x2, 0x2, 0x2, 0x3ff, 0x400, 0x5, 0xb4, 0x5b, 
    0x2, 0x400, 0x401, 0x8, 0x42, 0x1, 0x2, 0x401, 0x40b, 0x3, 0x2, 0x2, 
    0x2, 0x402, 0x403, 0x7, 0x9c, 0x2, 0x2, 0x403, 0x40b, 0x8, 0x42, 0x1, 
    0x2, 0x404, 0x405, 0x5, 0xc2, 0x62, 0x2, 0x405, 0x406, 0x8, 0x42, 0x1, 
    0x2, 0x406, 0x40b, 0x3, 0x2, 0x2, 0x2, 0x407, 0x408, 0x5, 0xb8, 0x5d, 
    0x2, 0x408, 0x409, 0x8, 0x42, 0x1, 0x2, 0x409, 0x40b, 0x3, 0x2, 0x2, 
    0x2, 0x40a, 0x3ff, 0x3, 0x2, 0x2, 0x2, 0x40a, 0x402, 0x3, 0x2, 0x2, 
    0x2, 0x40a, 0x404, 0x3, 0x2, 0x2, 0x2, 0x40a, 0x407, 0x3, 0x2, 0x2, 
    0x2, 0x40b, 0x83, 0x3, 0x2, 0x2, 0x2, 0x40c, 0x40f, 0x5, 0xb2, 0x5a, 
    0x2, 0x40d, 0x40f, 0x5, 0xb8, 0x5d, 0x2, 0x40e, 0x40c, 0x3, 0x2, 0x2, 
    0x2, 0x40e, 0x40d, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x85, 0x3, 0x2, 0x2, 0x2, 
    0x410, 0x411, 0x5, 0x84, 0x43, 0x2, 0x411, 0x412, 0x7, 0x11, 0x2, 0x2, 
    0x412, 0x413, 0x5, 0xb2, 0x5a, 0x2, 0x413, 0x414, 0x8, 0x44, 0x1, 0x2, 
    0x414, 0x429, 0x3, 0x2, 0x2, 0x2, 0x415, 0x416, 0x7, 0x6, 0x2, 0x2, 
    0x416, 0x417, 0x5, 0xb2, 0x5a, 0x2, 0x417, 0x418, 0x7, 0x7, 0x2, 0x2, 
    0x418, 0x419, 0x7, 0x11, 0x2, 0x2, 0x419, 0x41a, 0x5, 0xb2, 0x5a, 0x2, 
    0x41a, 0x41b, 0x8, 0x44, 0x1, 0x2, 0x41b, 0x429, 0x3, 0x2, 0x2, 0x2, 
    0x41c, 0x41d, 0x5, 0x8e, 0x48, 0x2, 0x41d, 0x41e, 0x8, 0x44, 0x1, 0x2, 
    0x41e, 0x429, 0x3, 0x2, 0x2, 0x2, 0x41f, 0x420, 0x5, 0x90, 0x49, 0x2, 
    0x420, 0x421, 0x8, 0x44, 0x1, 0x2, 0x421, 0x429, 0x3, 0x2, 0x2, 0x2, 
    0x422, 0x423, 0x5, 0x66, 0x34, 0x2, 0x423, 0x424, 0x8, 0x44, 0x1, 0x2, 
    0x424, 0x429, 0x3, 0x2, 0x2, 0x2, 0x425, 0x426, 0x5, 0x84, 0x43, 0x2, 
    0x426, 0x427, 0x8, 0x44, 0x1, 0x2, 0x427, 0x429, 0x3, 0x2, 0x2, 0x2, 
    0x428, 0x410, 0x3, 0x2, 0x2, 0x2, 0x428, 0x415, 0x3, 0x2, 0x2, 0x2, 
    0x428, 0x41c, 0x3, 0x2, 0x2, 0x2, 0x428, 0x41f, 0x3, 0x2, 0x2, 0x2, 
    0x428, 0x422, 0x3, 0x2, 0x2, 0x2, 0x428, 0x425, 0x3, 0x2, 0x2, 0x2, 
    0x429, 0x87, 0x3, 0x2, 0x2, 0x2, 0x42a, 0x42b, 0x5, 0x84, 0x43, 0x2, 
    0x42b, 0x42c, 0x8, 0x45, 0x1, 0x2, 0x42c, 0x431, 0x3, 0x2, 0x2, 0x2, 
    0x42d, 0x42e, 0x5, 0xa, 0x6, 0x2, 0x42e, 0x42f, 0x8, 0x45, 0x1, 0x2, 
    0x42f, 0x431, 0x3, 0x2, 0x2, 0x2, 0x430, 0x42a, 0x3, 0x2, 0x2, 0x2, 
    0x430, 0x42d, 0x3, 0x2, 0x2, 0x2, 0x431, 0x89, 0x3, 0x2, 0x2, 0x2, 0x432, 
    0x435, 0x5, 0x88, 0x45, 0x2, 0x433, 0x435, 0x5, 0x76, 0x3c, 0x2, 0x434, 
    0x432, 0x3, 0x2, 0x2, 0x2, 0x434, 0x433, 0x3, 0x2, 0x2, 0x2, 0x435, 
    0x8b, 0x3, 0x2, 0x2, 0x2, 0x436, 0x43b, 0x5, 0x8a, 0x46, 0x2, 0x437, 
    0x438, 0x7, 0xe, 0x2, 0x2, 0x438, 0x43a, 0x5, 0x8a, 0x46, 0x2, 0x439, 
    0x437, 0x3, 0x2, 0x2, 0x2, 0x43a, 0x43d, 0x3, 0x2, 0x2, 0x2, 0x43b, 
    0x439, 0x3, 0x2, 0x2, 0x2, 0x43b, 0x43c, 0x3, 0x2, 0x2, 0x2, 0x43c, 
    0x43f, 0x3, 0x2, 0x2, 0x2, 0x43d, 0x43b, 0x3, 0x2, 0x2, 0x2, 0x43e, 
    0x440, 0x7, 0xe, 0x2, 0x2, 0x43f, 0x43e, 0x3, 0x2, 0x2, 0x2, 0x43f, 
    0x440, 0x3, 0x2, 0x2, 0x2, 0x440, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x441, 0x442, 
    0x5, 0xcc, 0x67, 0x2, 0x442, 0x443, 0x7, 0x8, 0x2, 0x2, 0x443, 0x445, 
    0x7, 0x9, 0x2, 0x2, 0x444, 0x446, 0x5, 0xd4, 0x6b, 0x2, 0x445, 0x444, 
    0x3, 0x2, 0x2, 0x2, 0x445, 0x446, 0x3, 0x2, 0x2, 0x2, 0x446, 0x447, 
    0x3, 0x2, 0x2, 0x2, 0x447, 0x448, 0x7, 0xa, 0x2, 0x2, 0x448, 0x449, 
    0x5, 0x72, 0x3a, 0x2, 0x449, 0x44a, 0x7, 0xc, 0x2, 0x2, 0x44a, 0x8f, 
    0x3, 0x2, 0x2, 0x2, 0x44b, 0x44c, 0x5, 0xce, 0x68, 0x2, 0x44c, 0x44f, 
    0x7, 0x8, 0x2, 0x2, 0x44d, 0x450, 0x5, 0xb4, 0x5b, 0x2, 0x44e, 0x450, 
    0x5, 0x8, 0x5, 0x2, 0x44f, 0x44d, 0x3, 0x2, 0x2, 0x2, 0x44f, 0x44e, 
    0x3, 0x2, 0x2, 0x2, 0x450, 0x452, 0x3, 0x2, 0x2, 0x2, 0x451, 0x453, 
    0x5, 0xd4, 0x6b, 0x2, 0x452, 0x451, 0x3, 0x2, 0x2, 0x2, 0x452, 0x453, 
    0x3, 0x2, 0x2, 0x2, 0x453, 0x454, 0x3, 0x2, 0x2, 0x2, 0x454, 0x455, 
    0x7, 0x9, 0x2, 0x2, 0x455, 0x456, 0x7, 0xa, 0x2, 0x2, 0x456, 0x457, 
    0x5, 0x72, 0x3a, 0x2, 0x457, 0x458, 0x7, 0xc, 0x2, 0x2, 0x458, 0x91, 
    0x3, 0x2, 0x2, 0x2, 0x459, 0x45e, 0x5, 0x94, 0x4b, 0x2, 0x45a, 0x45b, 
    0x7, 0xe, 0x2, 0x2, 0x45b, 0x45d, 0x5, 0x94, 0x4b, 0x2, 0x45c, 0x45a, 
    0x3, 0x2, 0x2, 0x2, 0x45d, 0x460, 0x3, 0x2, 0x2, 0x2, 0x45e, 0x45c, 
    0x3, 0x2, 0x2, 0x2, 0x45e, 0x45f, 0x3, 0x2, 0x2, 0x2, 0x45f, 0x93, 0x3, 
    0x2, 0x2, 0x2, 0x460, 0x45e, 0x3, 0x2, 0x2, 0x2, 0x461, 0x464, 0x5, 
    0x76, 0x3c, 0x2, 0x462, 0x464, 0x5, 0xb2, 0x5a, 0x2, 0x463, 0x461, 0x3, 
    0x2, 0x2, 0x2, 0x463, 0x462, 0x3, 0x2, 0x2, 0x2, 0x464, 0x95, 0x3, 0x2, 
    0x2, 0x2, 0x465, 0x46a, 0x5, 0xb2, 0x5a, 0x2, 0x466, 0x467, 0x7, 0xe, 
    0x2, 0x2, 0x467, 0x469, 0x5, 0xb2, 0x5a, 0x2, 0x468, 0x466, 0x3, 0x2, 
    0x2, 0x2, 0x469, 0x46c, 0x3, 0x2, 0x2, 0x2, 0x46a, 0x468, 0x3, 0x2, 
    0x2, 0x2, 0x46a, 0x46b, 0x3, 0x2, 0x2, 0x2, 0x46b, 0x46d, 0x3, 0x2, 
    0x2, 0x2, 0x46c, 0x46a, 0x3, 0x2, 0x2, 0x2, 0x46d, 0x46e, 0x8, 0x4c, 
    0x1, 0x2, 0x46e, 0x97, 0x3, 0x2, 0x2, 0x2, 0x46f, 0x470, 0x9, 0x3, 0x2, 
    0x2, 0x470, 0x99, 0x3, 0x2, 0x2, 0x2, 0x471, 0x472, 0x9, 0x4, 0x2, 0x2, 
    0x472, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x473, 0x474, 0x7, 0x1d, 0x2, 0x2, 
    0x474, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x475, 0x476, 0x9, 0x5, 0x2, 0x2, 0x476, 
    0x9f, 0x3, 0x2, 0x2, 0x2, 0x477, 0x478, 0x9, 0x6, 0x2, 0x2, 0x478, 0xa1, 
    0x3, 0x2, 0x2, 0x2, 0x479, 0x47a, 0x9, 0x7, 0x2, 0x2, 0x47a, 0xa3, 0x3, 
    0x2, 0x2, 0x2, 0x47b, 0x47c, 0x9, 0x8, 0x2, 0x2, 0x47c, 0xa5, 0x3, 0x2, 
    0x2, 0x2, 0x47d, 0x47e, 0x7, 0x48, 0x2, 0x2, 0x47e, 0xa7, 0x3, 0x2, 
    0x2, 0x2, 0x47f, 0x480, 0x7, 0x5e, 0x2, 0x2, 0x480, 0xa9, 0x3, 0x2, 
    0x2, 0x2, 0x481, 0x482, 0x9, 0x9, 0x2, 0x2, 0x482, 0xab, 0x3, 0x2, 0x2, 
    0x2, 0x483, 0x484, 0x7, 0x2a, 0x2, 0x2, 0x484, 0xad, 0x3, 0x2, 0x2, 
    0x2, 0x485, 0x486, 0x7, 0x2c, 0x2, 0x2, 0x486, 0xaf, 0x3, 0x2, 0x2, 
    0x2, 0x487, 0x488, 0x7, 0x2b, 0x2, 0x2, 0x488, 0xb1, 0x3, 0x2, 0x2, 
    0x2, 0x489, 0x48a, 0x8, 0x5a, 0x1, 0x2, 0x48a, 0x48b, 0x5, 0x38, 0x1d, 
    0x2, 0x48b, 0x48c, 0x5, 0x32, 0x1a, 0x2, 0x48c, 0x48d, 0x8, 0x5a, 0x1, 
    0x2, 0x48d, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x48e, 0x490, 0x7, 0x64, 0x2, 
    0x2, 0x48f, 0x48e, 0x3, 0x2, 0x2, 0x2, 0x48f, 0x490, 0x3, 0x2, 0x2, 
    0x2, 0x490, 0x491, 0x3, 0x2, 0x2, 0x2, 0x491, 0x493, 0x5, 0xbc, 0x5f, 
    0x2, 0x492, 0x494, 0x5, 0xf4, 0x7b, 0x2, 0x493, 0x492, 0x3, 0x2, 0x2, 
    0x2, 0x493, 0x494, 0x3, 0x2, 0x2, 0x2, 0x494, 0x495, 0x3, 0x2, 0x2, 
    0x2, 0x495, 0x496, 0x7, 0x3d, 0x2, 0x2, 0x496, 0x497, 0x5, 0xbe, 0x60, 
    0x2, 0x497, 0x498, 0x8, 0x5a, 0x1, 0x2, 0x498, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x499, 0x49a, 0x5, 0x3a, 0x1e, 0x2, 0x49a, 0x49b, 0x8, 0x5a, 0x1, 
    0x2, 0x49b, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x49c, 0x49d, 0x7, 0x8, 0x2, 
    0x2, 0x49d, 0x49e, 0x5, 0x96, 0x4c, 0x2, 0x49e, 0x49f, 0x7, 0x9, 0x2, 
    0x2, 0x49f, 0x4a0, 0x8, 0x5a, 0x1, 0x2, 0x4a0, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4a1, 0x4a2, 0x7, 0x4c, 0x2, 0x2, 0x4a2, 0x4a3, 0x5, 0xb2, 0x5a, 
    0x2, 0x4a3, 0x4a5, 0x7, 0x8, 0x2, 0x2, 0x4a4, 0x4a6, 0x5, 0x92, 0x4a, 
    0x2, 0x4a5, 0x4a4, 0x3, 0x2, 0x2, 0x2, 0x4a5, 0x4a6, 0x3, 0x2, 0x2, 
    0x2, 0x4a6, 0x4a7, 0x3, 0x2, 0x2, 0x2, 0x4a7, 0x4a8, 0x7, 0x9, 0x2, 
    0x2, 0x4a8, 0x4a9, 0x8, 0x5a, 0x1, 0x2, 0x4a9, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4aa, 0x4ab, 0x7, 0x4c, 0x2, 0x2, 0x4ab, 0x4ac, 0x5, 0xb2, 0x5a, 
    0x29, 0x4ac, 0x4ad, 0x8, 0x5a, 0x1, 0x2, 0x4ad, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4ae, 0x4af, 0x5, 0x98, 0x4d, 0x2, 0x4af, 0x4b0, 0x5, 0xb2, 0x5a, 
    0x27, 0x4b0, 0x4b1, 0x8, 0x5a, 0x1, 0x2, 0x4b1, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4b2, 0x4b3, 0x5, 0x9a, 0x4e, 0x2, 0x4b3, 0x4b4, 0x5, 0xb2, 0x5a, 
    0x26, 0x4b4, 0x4b5, 0x8, 0x5a, 0x1, 0x2, 0x4b5, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4b6, 0x4b7, 0x5, 0x8, 0x5, 0x2, 0x4b7, 0x4b8, 0x5, 0xc0, 0x61, 
    0x2, 0x4b8, 0x4b9, 0x5, 0xb2, 0x5a, 0x15, 0x4b9, 0x4ba, 0x8, 0x5a, 0x1, 
    0x2, 0x4ba, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4bb, 0x4bc, 0x5, 0xc6, 0x64, 
    0x2, 0x4bc, 0x4bd, 0x8, 0x5a, 0x1, 0x2, 0x4bd, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4be, 0x4bf, 0x5, 0x6e, 0x38, 0x2, 0x4bf, 0x4c0, 0x8, 0x5a, 0x1, 
    0x2, 0x4c0, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4c1, 0x4c2, 0x5, 0x6a, 0x36, 
    0x2, 0x4c2, 0x4c3, 0x8, 0x5a, 0x1, 0x2, 0x4c3, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4c4, 0x4c5, 0x5, 0x68, 0x35, 0x2, 0x4c5, 0x4c6, 0x8, 0x5a, 0x1, 
    0x2, 0x4c6, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4c7, 0x4c9, 0x7, 0x74, 0x2, 
    0x2, 0x4c8, 0x4ca, 0x7, 0x1a, 0x2, 0x2, 0x4c9, 0x4c8, 0x3, 0x2, 0x2, 
    0x2, 0x4c9, 0x4ca, 0x3, 0x2, 0x2, 0x2, 0x4ca, 0x4cb, 0x3, 0x2, 0x2, 
    0x2, 0x4cb, 0x4cc, 0x5, 0xb2, 0x5a, 0xe, 0x4cc, 0x4cd, 0x8, 0x5a, 0x1, 
    0x2, 0x4cd, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4ce, 0x4cf, 0x7, 0x75, 0x2, 
    0x2, 0x4cf, 0x4d0, 0x5, 0xb2, 0x5a, 0xd, 0x4d0, 0x4d1, 0x8, 0x5a, 0x1, 
    0x2, 0x4d1, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4d2, 0x4d3, 0x7, 0x6b, 0x2, 
    0x2, 0x4d3, 0x4d4, 0x7, 0x8, 0x2, 0x2, 0x4d4, 0x4d5, 0x5, 0xb2, 0x5a, 
    0x2, 0x4d5, 0x4d6, 0x7, 0x9, 0x2, 0x2, 0x4d6, 0x4d7, 0x8, 0x5a, 0x1, 
    0x2, 0x4d7, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4d8, 0x4d9, 0x5, 0xb6, 0x5c, 
    0x2, 0x4d9, 0x4da, 0x7, 0x13, 0x2, 0x2, 0x4da, 0x4db, 0x5, 0xb4, 0x5b, 
    0x2, 0x4db, 0x4dc, 0x8, 0x5a, 0x1, 0x2, 0x4dc, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4dd, 0x4de, 0x7, 0x58, 0x2, 0x2, 0x4de, 0x4f7, 0x8, 0x5a, 0x1, 
    0x2, 0x4df, 0x4e0, 0x5, 0xb4, 0x5b, 0x2, 0x4e0, 0x4e1, 0x8, 0x5a, 0x1, 
    0x2, 0x4e1, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4e2, 0x4e3, 0x7, 0x68, 0x2, 
    0x2, 0x4e3, 0x4f7, 0x8, 0x5a, 0x1, 0x2, 0x4e4, 0x4e5, 0x5, 0xc4, 0x63, 
    0x2, 0x4e5, 0x4e6, 0x8, 0x5a, 0x1, 0x2, 0x4e6, 0x4f7, 0x3, 0x2, 0x2, 
    0x2, 0x4e7, 0x4e8, 0x5, 0xc6, 0x64, 0x2, 0x4e8, 0x4e9, 0x8, 0x5a, 0x1, 
    0x2, 0x4e9, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4ea, 0x4ec, 0x7, 0x6, 0x2, 
    0x2, 0x4eb, 0x4ed, 0x5, 0x7a, 0x3e, 0x2, 0x4ec, 0x4eb, 0x3, 0x2, 0x2, 
    0x2, 0x4ec, 0x4ed, 0x3, 0x2, 0x2, 0x2, 0x4ed, 0x4ee, 0x3, 0x2, 0x2, 
    0x2, 0x4ee, 0x4ef, 0x7, 0x7, 0x2, 0x2, 0x4ef, 0x4f7, 0x8, 0x5a, 0x1, 
    0x2, 0x4f0, 0x4f2, 0x7, 0xa, 0x2, 0x2, 0x4f1, 0x4f3, 0x5, 0x80, 0x41, 
    0x2, 0x4f2, 0x4f1, 0x3, 0x2, 0x2, 0x2, 0x4f2, 0x4f3, 0x3, 0x2, 0x2, 
    0x2, 0x4f3, 0x4f4, 0x3, 0x2, 0x2, 0x2, 0x4f4, 0x4f5, 0x7, 0xc, 0x2, 
    0x2, 0x4f5, 0x4f7, 0x8, 0x5a, 0x1, 0x2, 0x4f6, 0x489, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x48f, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x499, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x49c, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4a1, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4aa, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4ae, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4b2, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4b6, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4bb, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4be, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4c1, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4c4, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4c7, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4ce, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4d2, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4d8, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4dd, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4df, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4e2, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4e4, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4e7, 0x3, 0x2, 0x2, 0x2, 0x4f6, 0x4ea, 0x3, 0x2, 0x2, 
    0x2, 0x4f6, 0x4f0, 0x3, 0x2, 0x2, 0x2, 0x4f7, 0x575, 0x3, 0x2, 0x2, 
    0x2, 0x4f8, 0x4f9, 0xc, 0x25, 0x2, 0x2, 0x4f9, 0x4fa, 0x5, 0x9c, 0x4f, 
    0x2, 0x4fa, 0x4fb, 0x5, 0xb2, 0x5a, 0x26, 0x4fb, 0x4fc, 0x8, 0x5a, 0x1, 
    0x2, 0x4fc, 0x574, 0x3, 0x2, 0x2, 0x2, 0x4fd, 0x4fe, 0xc, 0x24, 0x2, 
    0x2, 0x4fe, 0x4ff, 0x5, 0x9e, 0x50, 0x2, 0x4ff, 0x500, 0x5, 0xb2, 0x5a, 
    0x25, 0x500, 0x501, 0x8, 0x5a, 0x1, 0x2, 0x501, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x502, 0x503, 0xc, 0x23, 0x2, 0x2, 0x503, 0x504, 0x5, 0xa0, 0x51, 
    0x2, 0x504, 0x505, 0x5, 0xb2, 0x5a, 0x24, 0x505, 0x506, 0x8, 0x5a, 0x1, 
    0x2, 0x506, 0x574, 0x3, 0x2, 0x2, 0x2, 0x507, 0x508, 0xc, 0x22, 0x2, 
    0x2, 0x508, 0x509, 0x5, 0xa2, 0x52, 0x2, 0x509, 0x50a, 0x5, 0xb2, 0x5a, 
    0x23, 0x50a, 0x50b, 0x8, 0x5a, 0x1, 0x2, 0x50b, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x50c, 0x50d, 0xc, 0x21, 0x2, 0x2, 0x50d, 0x50e, 0x5, 0xa4, 0x53, 
    0x2, 0x50e, 0x50f, 0x5, 0xb2, 0x5a, 0x22, 0x50f, 0x510, 0x8, 0x5a, 0x1, 
    0x2, 0x510, 0x574, 0x3, 0x2, 0x2, 0x2, 0x511, 0x512, 0xc, 0x20, 0x2, 
    0x2, 0x512, 0x513, 0x5, 0xa6, 0x54, 0x2, 0x513, 0x514, 0x5, 0xb2, 0x5a, 
    0x21, 0x514, 0x515, 0x8, 0x5a, 0x1, 0x2, 0x515, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x516, 0x517, 0xc, 0x1f, 0x2, 0x2, 0x517, 0x518, 0x5, 0xa8, 0x55, 
    0x2, 0x518, 0x519, 0x5, 0xb2, 0x5a, 0x20, 0x519, 0x51a, 0x8, 0x5a, 0x1, 
    0x2, 0x51a, 0x574, 0x3, 0x2, 0x2, 0x2, 0x51b, 0x51c, 0xc, 0x1e, 0x2, 
    0x2, 0x51c, 0x51d, 0x5, 0xaa, 0x56, 0x2, 0x51d, 0x51e, 0x5, 0xb2, 0x5a, 
    0x1f, 0x51e, 0x51f, 0x8, 0x5a, 0x1, 0x2, 0x51f, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x520, 0x521, 0xc, 0x1d, 0x2, 0x2, 0x521, 0x522, 0x5, 0xac, 0x57, 
    0x2, 0x522, 0x523, 0x5, 0xb2, 0x5a, 0x1e, 0x523, 0x524, 0x8, 0x5a, 0x1, 
    0x2, 0x524, 0x574, 0x3, 0x2, 0x2, 0x2, 0x525, 0x526, 0xc, 0x1c, 0x2, 
    0x2, 0x526, 0x527, 0x5, 0xb0, 0x59, 0x2, 0x527, 0x528, 0x5, 0xb2, 0x5a, 
    0x1d, 0x528, 0x529, 0x8, 0x5a, 0x1, 0x2, 0x529, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x52a, 0x52b, 0xc, 0x1b, 0x2, 0x2, 0x52b, 0x52c, 0x5, 0xae, 0x58, 
    0x2, 0x52c, 0x52d, 0x5, 0xb2, 0x5a, 0x1c, 0x52d, 0x52e, 0x8, 0x5a, 0x1, 
    0x2, 0x52e, 0x574, 0x3, 0x2, 0x2, 0x2, 0x52f, 0x530, 0xc, 0x1a, 0x2, 
    0x2, 0x530, 0x531, 0x7, 0x2d, 0x2, 0x2, 0x531, 0x532, 0x5, 0xb2, 0x5a, 
    0x1b, 0x532, 0x533, 0x8, 0x5a, 0x1, 0x2, 0x533, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x534, 0x535, 0xc, 0x19, 0x2, 0x2, 0x535, 0x536, 0x7, 0x2e, 0x2, 
    0x2, 0x536, 0x537, 0x5, 0xb2, 0x5a, 0x1a, 0x537, 0x538, 0x8, 0x5a, 0x1, 
    0x2, 0x538, 0x574, 0x3, 0x2, 0x2, 0x2, 0x539, 0x53a, 0xc, 0x18, 0x2, 
    0x2, 0x53a, 0x53b, 0x7, 0x2f, 0x2, 0x2, 0x53b, 0x53c, 0x5, 0xb2, 0x5a, 
    0x19, 0x53c, 0x53d, 0x8, 0x5a, 0x1, 0x2, 0x53d, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x53e, 0x53f, 0xc, 0x17, 0x2, 0x2, 0x53f, 0x540, 0x7, 0x10, 0x2, 
    0x2, 0x540, 0x541, 0x5, 0xb2, 0x5a, 0x2, 0x541, 0x542, 0x7, 0x11, 0x2, 
    0x2, 0x542, 0x543, 0x5, 0xb2, 0x5a, 0x18, 0x543, 0x544, 0x8, 0x5a, 0x1, 
    0x2, 0x544, 0x574, 0x3, 0x2, 0x2, 0x2, 0x545, 0x546, 0xc, 0x16, 0x2, 
    0x2, 0x546, 0x547, 0x7, 0x9a, 0x2, 0x2, 0x547, 0x548, 0x7, 0x11, 0x2, 
    0x2, 0x548, 0x549, 0x5, 0xb2, 0x5a, 0x17, 0x549, 0x54a, 0x8, 0x5a, 0x1, 
    0x2, 0x54a, 0x574, 0x3, 0x2, 0x2, 0x2, 0x54b, 0x54c, 0xc, 0x14, 0x2, 
    0x2, 0x54c, 0x54d, 0x5, 0xc0, 0x61, 0x2, 0x54d, 0x54e, 0x5, 0xb2, 0x5a, 
    0x15, 0x54e, 0x54f, 0x8, 0x5a, 0x1, 0x2, 0x54f, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x550, 0x551, 0xc, 0x2c, 0x2, 0x2, 0x551, 0x552, 0x5, 0xba, 0x5e, 
    0x2, 0x552, 0x553, 0x8, 0x5a, 0x1, 0x2, 0x553, 0x574, 0x3, 0x2, 0x2, 
    0x2, 0x554, 0x556, 0xc, 0x2a, 0x2, 0x2, 0x555, 0x557, 0x7, 0x30, 0x2, 
    0x2, 0x556, 0x555, 0x3, 0x2, 0x2, 0x2, 0x556, 0x557, 0x3, 0x2, 0x2, 
    0x2, 0x557, 0x558, 0x3, 0x2, 0x2, 0x2, 0x558, 0x55a, 0x7, 0x8, 0x2, 
    0x2, 0x559, 0x55b, 0x5, 0x92, 0x4a, 0x2, 0x55a, 0x559, 0x3, 0x2, 0x2, 
    0x2, 0x55a, 0x55b, 0x3, 0x2, 0x2, 0x2, 0x55b, 0x55c, 0x3, 0x2, 0x2, 
    0x2, 0x55c, 0x55d, 0x7, 0x9, 0x2, 0x2, 0x55d, 0x574, 0x8, 0x5a, 0x1, 
    0x2, 0x55e, 0x55f, 0xc, 0x28, 0x2, 0x2, 0x55f, 0x560, 0x6, 0x5a, 0x1e, 
    0x2, 0x560, 0x561, 0x5, 0x98, 0x4d, 0x2, 0x561, 0x562, 0x8, 0x5a, 0x1, 
    0x2, 0x562, 0x574, 0x3, 0x2, 0x2, 0x2, 0x563, 0x564, 0xc, 0x12, 0x2, 
    0x2, 0x564, 0x565, 0x5, 0xc6, 0x64, 0x2, 0x565, 0x566, 0x8, 0x5a, 0x1, 
    0x2, 0x566, 0x574, 0x3, 0x2, 0x2, 0x2, 0x567, 0x568, 0xc, 0x3, 0x2, 
    0x2, 0x568, 0x56f, 0x7, 0x61, 0x2, 0x2, 0x569, 0x56c, 0x5, 0xee, 0x78, 
    0x2, 0x56a, 0x56b, 0x7, 0x6, 0x2, 0x2, 0x56b, 0x56d, 0x7, 0x7, 0x2, 
    0x2, 0x56c, 0x56a, 0x3, 0x2, 0x2, 0x2, 0x56c, 0x56d, 0x3, 0x2, 0x2, 
    0x2, 0x56d, 0x570, 0x3, 0x2, 0x2, 0x2, 0x56e, 0x570, 0x5, 0xb2, 0x5a, 
    0x2, 0x56f, 0x569, 0x3, 0x2, 0x2, 0x2, 0x56f, 0x56e, 0x3, 0x2, 0x2, 
    0x2, 0x570, 0x571, 0x3, 0x2, 0x2, 0x2, 0x571, 0x572, 0x8, 0x5a, 0x1, 
    0x2, 0x572, 0x574, 0x3, 0x2, 0x2, 0x2, 0x573, 0x4f8, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x4fd, 0x3, 0x2, 0x2, 0x2, 0x573, 0x502, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x507, 0x3, 0x2, 0x2, 0x2, 0x573, 0x50c, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x511, 0x3, 0x2, 0x2, 0x2, 0x573, 0x516, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x51b, 0x3, 0x2, 0x2, 0x2, 0x573, 0x520, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x525, 0x3, 0x2, 0x2, 0x2, 0x573, 0x52a, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x52f, 0x3, 0x2, 0x2, 0x2, 0x573, 0x534, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x539, 0x3, 0x2, 0x2, 0x2, 0x573, 0x53e, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x545, 0x3, 0x2, 0x2, 0x2, 0x573, 0x54b, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x550, 0x3, 0x2, 0x2, 0x2, 0x573, 0x554, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x55e, 0x3, 0x2, 0x2, 0x2, 0x573, 0x563, 0x3, 0x2, 0x2, 
    0x2, 0x573, 0x567, 0x3, 0x2, 0x2, 0x2, 0x574, 0x577, 0x3, 0x2, 0x2, 
    0x2, 0x575, 0x573, 0x3, 0x2, 0x2, 0x2, 0x575, 0x576, 0x3, 0x2, 0x2, 
    0x2, 0x576, 0xb3, 0x3, 0x2, 0x2, 0x2, 0x577, 0x575, 0x3, 0x2, 0x2, 0x2, 
    0x578, 0x57b, 0x7, 0x9b, 0x2, 0x2, 0x579, 0x57a, 0x6, 0x5b, 0x21, 0x2, 
    0x57a, 0x57c, 0x5, 0xd4, 0x6b, 0x2, 0x57b, 0x579, 0x3, 0x2, 0x2, 0x2, 
    0x57b, 0x57c, 0x3, 0x2, 0x2, 0x2, 0x57c, 0x57d, 0x3, 0x2, 0x2, 0x2, 
    0x57d, 0x593, 0x8, 0x5b, 0x1, 0x2, 0x57e, 0x57f, 0x9, 0xa, 0x2, 0x2, 
    0x57f, 0x580, 0x7, 0x9b, 0x2, 0x2, 0x580, 0x593, 0x8, 0x5b, 0x1, 0x2, 
    0x581, 0x582, 0x7, 0x9b, 0x2, 0x2, 0x582, 0x583, 0x9, 0xa, 0x2, 0x2, 
    0x583, 0x593, 0x8, 0x5b, 0x1, 0x2, 0x584, 0x587, 0x5, 0xc2, 0x62, 0x2, 
    0x585, 0x588, 0x7, 0x9b, 0x2, 0x2, 0x586, 0x588, 0x5, 0xca, 0x66, 0x2, 
    0x587, 0x585, 0x3, 0x2, 0x2, 0x2, 0x587, 0x586, 0x3, 0x2, 0x2, 0x2, 
    0x588, 0x589, 0x3, 0x2, 0x2, 0x2, 0x589, 0x58a, 0x8, 0x5b, 0x1, 0x2, 
    0x58a, 0x593, 0x3, 0x2, 0x2, 0x2, 0x58b, 0x590, 0x6, 0x5b, 0x22, 0x2, 
    0x58c, 0x591, 0x5, 0xca, 0x66, 0x2, 0x58d, 0x591, 0x5, 0xda, 0x6e, 0x2, 
    0x58e, 0x591, 0x5, 0xdc, 0x6f, 0x2, 0x58f, 0x591, 0x7, 0x3f, 0x2, 0x2, 
    0x590, 0x58c, 0x3, 0x2, 0x2, 0x2, 0x590, 0x58d, 0x3, 0x2, 0x2, 0x2, 
    0x590, 0x58e, 0x3, 0x2, 0x2, 0x2, 0x590, 0x58f, 0x3, 0x2, 0x2, 0x2, 
    0x591, 0x593, 0x3, 0x2, 0x2, 0x2, 0x592, 0x578, 0x3, 0x2, 0x2, 0x2, 
    0x592, 0x57e, 0x3, 0x2, 0x2, 0x2, 0x592, 0x581, 0x3, 0x2, 0x2, 0x2, 
    0x592, 0x584, 0x3, 0x2, 0x2, 0x2, 0x592, 0x58b, 0x3, 0x2, 0x2, 0x2, 
    0x593, 0xb5, 0x3, 0x2, 0x2, 0x2, 0x594, 0x595, 0x7, 0x4c, 0x2, 0x2, 
    0x595, 0x599, 0x8, 0x5c, 0x1, 0x2, 0x596, 0x597, 0x7, 0x6b, 0x2, 0x2, 
    0x597, 0x599, 0x8, 0x5c, 0x1, 0x2, 0x598, 0x594, 0x3, 0x2, 0x2, 0x2, 
    0x598, 0x596, 0x3, 0x2, 0x2, 0x2, 0x599, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x59a, 
    0x59b, 0x7, 0x1e, 0x2, 0x2, 0x59b, 0x59c, 0x7, 0x9b, 0x2, 0x2, 0x59c, 
    0x59d, 0x8, 0x5d, 0x1, 0x2, 0x59d, 0xb9, 0x3, 0x2, 0x2, 0x2, 0x59e, 
    0x59f, 0x7, 0x6, 0x2, 0x2, 0x59f, 0x5a0, 0x5, 0x96, 0x4c, 0x2, 0x5a0, 
    0x5a1, 0x7, 0x7, 0x2, 0x2, 0x5a1, 0x5a2, 0x8, 0x5e, 0x1, 0x2, 0x5a2, 
    0x5b6, 0x3, 0x2, 0x2, 0x2, 0x5a3, 0x5a4, 0x7, 0x30, 0x2, 0x2, 0x5a4, 
    0x5a5, 0x7, 0x6, 0x2, 0x2, 0x5a5, 0x5a6, 0x5, 0x96, 0x4c, 0x2, 0x5a6, 
    0x5a7, 0x7, 0x7, 0x2, 0x2, 0x5a7, 0x5a8, 0x8, 0x5e, 0x1, 0x2, 0x5a8, 
    0x5b6, 0x3, 0x2, 0x2, 0x2, 0x5a9, 0x5aa, 0x7, 0x30, 0x2, 0x2, 0x5aa, 
    0x5ab, 0x5, 0xb4, 0x5b, 0x2, 0x5ab, 0x5ac, 0x8, 0x5e, 0x1, 0x2, 0x5ac, 
    0x5b6, 0x3, 0x2, 0x2, 0x2, 0x5ad, 0x5ae, 0x7, 0x13, 0x2, 0x2, 0x5ae, 
    0x5af, 0x5, 0xb4, 0x5b, 0x2, 0x5af, 0x5b0, 0x8, 0x5e, 0x1, 0x2, 0x5b0, 
    0x5b6, 0x3, 0x2, 0x2, 0x2, 0x5b1, 0x5b2, 0x7, 0x13, 0x2, 0x2, 0x5b2, 
    0x5b3, 0x5, 0xb8, 0x5d, 0x2, 0x5b3, 0x5b4, 0x8, 0x5e, 0x1, 0x2, 0x5b4, 
    0x5b6, 0x3, 0x2, 0x2, 0x2, 0x5b5, 0x59e, 0x3, 0x2, 0x2, 0x2, 0x5b5, 
    0x5a3, 0x3, 0x2, 0x2, 0x2, 0x5b5, 0x5a9, 0x3, 0x2, 0x2, 0x2, 0x5b5, 
    0x5ad, 0x3, 0x2, 0x2, 0x2, 0x5b5, 0x5b1, 0x3, 0x2, 0x2, 0x2, 0x5b6, 
    0xbb, 0x3, 0x2, 0x2, 0x2, 0x5b7, 0x5b9, 0x7, 0x8, 0x2, 0x2, 0x5b8, 0x5ba, 
    0x5, 0xe, 0x8, 0x2, 0x5b9, 0x5b8, 0x3, 0x2, 0x2, 0x2, 0x5b9, 0x5ba, 
    0x3, 0x2, 0x2, 0x2, 0x5ba, 0x5bb, 0x3, 0x2, 0x2, 0x2, 0x5bb, 0x5be, 
    0x7, 0x9, 0x2, 0x2, 0x5bc, 0x5be, 0x5, 0xb4, 0x5b, 0x2, 0x5bd, 0x5b7, 
    0x3, 0x2, 0x2, 0x2, 0x5bd, 0x5bc, 0x3, 0x2, 0x2, 0x2, 0x5be, 0xbd, 0x3, 
    0x2, 0x2, 0x2, 0x5bf, 0x5c2, 0x5, 0x32, 0x1a, 0x2, 0x5c0, 0x5c2, 0x5, 
    0xb2, 0x5a, 0x2, 0x5c1, 0x5bf, 0x3, 0x2, 0x2, 0x2, 0x5c1, 0x5c0, 0x3, 
    0x2, 0x2, 0x2, 0x5c2, 0xbf, 0x3, 0x2, 0x2, 0x2, 0x5c3, 0x5c4, 0x9, 0xb, 
    0x2, 0x2, 0x5c4, 0xc1, 0x3, 0x2, 0x2, 0x2, 0x5c5, 0x5c6, 0x9, 0xc, 0x2, 
    0x2, 0x5c6, 0xc3, 0x3, 0x2, 0x2, 0x2, 0x5c7, 0x5cf, 0x7, 0x3e, 0x2, 
    0x2, 0x5c8, 0x5cf, 0x7, 0x3f, 0x2, 0x2, 0x5c9, 0x5cf, 0x7, 0x9c, 0x2, 
    0x2, 0x5ca, 0x5cb, 0x7, 0x5, 0x2, 0x2, 0x5cb, 0x5cf, 0x8, 0x63, 0x1, 
    0x2, 0x5cc, 0x5cf, 0x5, 0xc2, 0x62, 0x2, 0x5cd, 0x5cf, 0x7, 0x45, 0x2, 
    0x2, 0x5ce, 0x5c7, 0x3, 0x2, 0x2, 0x2, 0x5ce, 0x5c8, 0x3, 0x2, 0x2, 
    0x2, 0x5ce, 0x5c9, 0x3, 0x2, 0x2, 0x2, 0x5ce, 0x5ca, 0x3, 0x2, 0x2, 
    0x2, 0x5ce, 0x5cc, 0x3, 0x2, 0x2, 0x2, 0x5ce, 0x5cd, 0x3, 0x2, 0x2, 
    0x2, 0x5cf, 0xc5, 0x3, 0x2, 0x2, 0x2, 0x5d0, 0x5d4, 0x7, 0x9d, 0x2, 
    0x2, 0x5d1, 0x5d3, 0x5, 0xc8, 0x65, 0x2, 0x5d2, 0x5d1, 0x3, 0x2, 0x2, 
    0x2, 0x5d3, 0x5d6, 0x3, 0x2, 0x2, 0x2, 0x5d4, 0x5d2, 0x3, 0x2, 0x2, 
    0x2, 0x5d4, 0x5d5, 0x3, 0x2, 0x2, 0x2, 0x5d5, 0x5d7, 0x3, 0x2, 0x2, 
    0x2, 0x5d6, 0x5d4, 0x3, 0x2, 0x2, 0x2, 0x5d7, 0x5d8, 0x7, 0x9d, 0x2, 
    0x2, 0x5d8, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x5d9, 0x5df, 0x7, 0xa4, 0x2, 
    0x2, 0x5da, 0x5db, 0x7, 0xa3, 0x2, 0x2, 0x5db, 0x5dc, 0x5, 0xb2, 0x5a, 
    0x2, 0x5dc, 0x5dd, 0x7, 0xb, 0x2, 0x2, 0x5dd, 0x5df, 0x3, 0x2, 0x2, 
    0x2, 0x5de, 0x5d9, 0x3, 0x2, 0x2, 0x2, 0x5de, 0x5da, 0x3, 0x2, 0x2, 
    0x2, 0x5df, 0xc9, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5e1, 0x9, 0xd, 0x2, 0x2, 
    0x5e1, 0xcb, 0x3, 0x2, 0x2, 0x2, 0x5e2, 0x5e3, 0x7, 0x8f, 0x2, 0x2, 
    0x5e3, 0x5e4, 0x5, 0x82, 0x42, 0x2, 0x5e4, 0xcd, 0x3, 0x2, 0x2, 0x2, 
    0x5e5, 0x5e6, 0x7, 0x90, 0x2, 0x2, 0x5e6, 0x5e7, 0x5, 0x82, 0x42, 0x2, 
    0x5e7, 0xcf, 0x3, 0x2, 0x2, 0x2, 0x5e8, 0x5ed, 0x7, 0xd, 0x2, 0x2, 0x5e9, 
    0x5ed, 0x7, 0x2, 0x2, 0x3, 0x5ea, 0x5ed, 0x6, 0x69, 0x23, 0x2, 0x5eb, 
    0x5ed, 0x6, 0x69, 0x24, 0x2, 0x5ec, 0x5e8, 0x3, 0x2, 0x2, 0x2, 0x5ec, 
    0x5e9, 0x3, 0x2, 0x2, 0x2, 0x5ec, 0x5ea, 0x3, 0x2, 0x2, 0x2, 0x5ec, 
    0x5eb, 0x3, 0x2, 0x2, 0x2, 0x5ed, 0xd1, 0x3, 0x2, 0x2, 0x2, 0x5ee, 0x5f3, 
    0x5, 0x8, 0x5, 0x2, 0x5ef, 0x5f0, 0x5, 0xb2, 0x5a, 0x2, 0x5f0, 0x5f1, 
    0x8, 0x6a, 0x1, 0x2, 0x5f1, 0x5f3, 0x3, 0x2, 0x2, 0x2, 0x5f2, 0x5ee, 
    0x3, 0x2, 0x2, 0x2, 0x5f2, 0x5ef, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0xd3, 0x3, 
    0x2, 0x2, 0x2, 0x5f4, 0x5f5, 0x7, 0x11, 0x2, 0x2, 0x5f5, 0x5f6, 0x5, 
    0xee, 0x78, 0x2, 0x5f6, 0x5f7, 0x8, 0x6b, 0x1, 0x2, 0x5f7, 0xd5, 0x3, 
    0x2, 0x2, 0x2, 0x5f8, 0x5f9, 0x5, 0xb4, 0x5b, 0x2, 0x5f9, 0x5fa, 0x7, 
    0x13, 0x2, 0x2, 0x5fa, 0x5fc, 0x3, 0x2, 0x2, 0x2, 0x5fb, 0x5f8, 0x3, 
    0x2, 0x2, 0x2, 0x5fc, 0x5fd, 0x3, 0x2, 0x2, 0x2, 0x5fd, 0x5fb, 0x3, 
    0x2, 0x2, 0x2, 0x5fd, 0x5fe, 0x3, 0x2, 0x2, 0x2, 0x5fe, 0x5ff, 0x3, 
    0x2, 0x2, 0x2, 0x5ff, 0x600, 0x5, 0xb4, 0x5b, 0x2, 0x600, 0x609, 0x3, 
    0x2, 0x2, 0x2, 0x601, 0x604, 0x7, 0x58, 0x2, 0x2, 0x602, 0x603, 0x7, 
    0x13, 0x2, 0x2, 0x603, 0x605, 0x5, 0xb4, 0x5b, 0x2, 0x604, 0x602, 0x3, 
    0x2, 0x2, 0x2, 0x605, 0x606, 0x3, 0x2, 0x2, 0x2, 0x606, 0x604, 0x3, 
    0x2, 0x2, 0x2, 0x606, 0x607, 0x3, 0x2, 0x2, 0x2, 0x607, 0x609, 0x3, 
    0x2, 0x2, 0x2, 0x608, 0x5fb, 0x3, 0x2, 0x2, 0x2, 0x608, 0x601, 0x3, 
    0x2, 0x2, 0x2, 0x609, 0xd7, 0x3, 0x2, 0x2, 0x2, 0x60a, 0x60d, 0x5, 0xb4, 
    0x5b, 0x2, 0x60b, 0x60d, 0x5, 0xd6, 0x6c, 0x2, 0x60c, 0x60a, 0x3, 0x2, 
    0x2, 0x2, 0x60c, 0x60b, 0x3, 0x2, 0x2, 0x2, 0x60d, 0xd9, 0x3, 0x2, 0x2, 
    0x2, 0x60e, 0x617, 0x7, 0x78, 0x2, 0x2, 0x60f, 0x617, 0x7, 0x77, 0x2, 
    0x2, 0x610, 0x617, 0x7, 0x79, 0x2, 0x2, 0x611, 0x617, 0x7, 0x3e, 0x2, 
    0x2, 0x612, 0x617, 0x7, 0x7a, 0x2, 0x2, 0x613, 0x614, 0x6, 0x6e, 0x25, 
    0x2, 0x614, 0x617, 0x7, 0x7b, 0x2, 0x2, 0x615, 0x617, 0x7, 0x7c, 0x2, 
    0x2, 0x616, 0x60e, 0x3, 0x2, 0x2, 0x2, 0x616, 0x60f, 0x3, 0x2, 0x2, 
    0x2, 0x616, 0x610, 0x3, 0x2, 0x2, 0x2, 0x616, 0x611, 0x3, 0x2, 0x2, 
    0x2, 0x616, 0x612, 0x3, 0x2, 0x2, 0x2, 0x616, 0x613, 0x3, 0x2, 0x2, 
    0x2, 0x616, 0x615, 0x3, 0x2, 0x2, 0x2, 0x617, 0xdb, 0x3, 0x2, 0x2, 0x2, 
    0x618, 0x619, 0x9, 0xe, 0x2, 0x2, 0x619, 0xdd, 0x3, 0x2, 0x2, 0x2, 0x61a, 
    0x61f, 0x5, 0xee, 0x78, 0x2, 0x61b, 0x61c, 0x7, 0xe, 0x2, 0x2, 0x61c, 
    0x61e, 0x5, 0xee, 0x78, 0x2, 0x61d, 0x61b, 0x3, 0x2, 0x2, 0x2, 0x61e, 
    0x621, 0x3, 0x2, 0x2, 0x2, 0x61f, 0x61d, 0x3, 0x2, 0x2, 0x2, 0x61f, 
    0x620, 0x3, 0x2, 0x2, 0x2, 0x620, 0x622, 0x3, 0x2, 0x2, 0x2, 0x621, 
    0x61f, 0x3, 0x2, 0x2, 0x2, 0x622, 0x623, 0x8, 0x70, 0x1, 0x2, 0x623, 
    0xdf, 0x3, 0x2, 0x2, 0x2, 0x624, 0x625, 0x9, 0xf, 0x2, 0x2, 0x625, 0xe1, 
    0x3, 0x2, 0x2, 0x2, 0x626, 0x62c, 0x5, 0xe4, 0x73, 0x2, 0x627, 0x628, 
    0x5, 0xe0, 0x71, 0x2, 0x628, 0x629, 0x5, 0xe4, 0x73, 0x2, 0x629, 0x62b, 
    0x3, 0x2, 0x2, 0x2, 0x62a, 0x627, 0x3, 0x2, 0x2, 0x2, 0x62b, 0x62e, 
    0x3, 0x2, 0x2, 0x2, 0x62c, 0x62a, 0x3, 0x2, 0x2, 0x2, 0x62c, 0x62d, 
    0x3, 0x2, 0x2, 0x2, 0x62d, 0x62f, 0x3, 0x2, 0x2, 0x2, 0x62e, 0x62c, 
    0x3, 0x2, 0x2, 0x2, 0x62f, 0x630, 0x8, 0x72, 0x1, 0x2, 0x630, 0xe3, 
    0x3, 0x2, 0x2, 0x2, 0x631, 0x632, 0x5, 0xb4, 0x5b, 0x2, 0x632, 0x633, 
    0x7, 0x11, 0x2, 0x2, 0x633, 0x634, 0x5, 0xee, 0x78, 0x2, 0x634, 0xe5, 
    0x3, 0x2, 0x2, 0x2, 0x635, 0x636, 0x9, 0x10, 0x2, 0x2, 0x636, 0xe7, 
    0x3, 0x2, 0x2, 0x2, 0x637, 0x638, 0x5, 0xe6, 0x74, 0x2, 0x638, 0x639, 
    0x7, 0xe, 0x2, 0x2, 0x639, 0x63a, 0x5, 0xee, 0x78, 0x2, 0x63a, 0x63b, 
    0x8, 0x75, 0x1, 0x2, 0x63b, 0xe9, 0x3, 0x2, 0x2, 0x2, 0x63c, 0x63d, 
    0x5, 0xe6, 0x74, 0x2, 0x63d, 0x63e, 0x7, 0x22, 0x2, 0x2, 0x63e, 0x63f, 
    0x5, 0xee, 0x78, 0x2, 0x63f, 0x640, 0x7, 0x23, 0x2, 0x2, 0x640, 0x659, 
    0x3, 0x2, 0x2, 0x2, 0x641, 0x642, 0x5, 0xe6, 0x74, 0x2, 0x642, 0x643, 
    0x7, 0x22, 0x2, 0x2, 0x643, 0x644, 0x5, 0xe6, 0x74, 0x2, 0x644, 0x645, 
    0x7, 0x22, 0x2, 0x2, 0x645, 0x649, 0x5, 0xee, 0x78, 0x2, 0x646, 0x647, 
    0x7, 0x23, 0x2, 0x2, 0x647, 0x64a, 0x7, 0x23, 0x2, 0x2, 0x648, 0x64a, 
    0x7, 0x1f, 0x2, 0x2, 0x649, 0x646, 0x3, 0x2, 0x2, 0x2, 0x649, 0x648, 
    0x3, 0x2, 0x2, 0x2, 0x64a, 0x659, 0x3, 0x2, 0x2, 0x2, 0x64b, 0x64c, 
    0x5, 0xe6, 0x74, 0x2, 0x64c, 0x64d, 0x7, 0x22, 0x2, 0x2, 0x64d, 0x64e, 
    0x5, 0xe6, 0x74, 0x2, 0x64e, 0x64f, 0x7, 0x22, 0x2, 0x2, 0x64f, 0x650, 
    0x5, 0xe6, 0x74, 0x2, 0x650, 0x651, 0x7, 0x22, 0x2, 0x2, 0x651, 0x656, 
    0x5, 0xee, 0x78, 0x2, 0x652, 0x653, 0x7, 0x23, 0x2, 0x2, 0x653, 0x654, 
    0x7, 0x23, 0x2, 0x2, 0x654, 0x657, 0x7, 0x23, 0x2, 0x2, 0x655, 0x657, 
    0x7, 0x21, 0x2, 0x2, 0x656, 0x652, 0x3, 0x2, 0x2, 0x2, 0x656, 0x655, 
    0x3, 0x2, 0x2, 0x2, 0x657, 0x659, 0x3, 0x2, 0x2, 0x2, 0x658, 0x63c, 
    0x3, 0x2, 0x2, 0x2, 0x658, 0x641, 0x3, 0x2, 0x2, 0x2, 0x658, 0x64b, 
    0x3, 0x2, 0x2, 0x2, 0x659, 0xeb, 0x3, 0x2, 0x2, 0x2, 0x65a, 0x65d, 0x5, 
    0xe8, 0x75, 0x2, 0x65b, 0x65d, 0x5, 0xea, 0x76, 0x2, 0x65c, 0x65a, 0x3, 
    0x2, 0x2, 0x2, 0x65c, 0x65b, 0x3, 0x2, 0x2, 0x2, 0x65d, 0xed, 0x3, 0x2, 
    0x2, 0x2, 0x65e, 0x65f, 0x8, 0x78, 0x1, 0x2, 0x65f, 0x660, 0x5, 0xda, 
    0x6e, 0x2, 0x660, 0x661, 0x8, 0x78, 0x1, 0x2, 0x661, 0x680, 0x3, 0x2, 
    0x2, 0x2, 0x662, 0x663, 0x5, 0xdc, 0x6f, 0x2, 0x663, 0x664, 0x8, 0x78, 
    0x1, 0x2, 0x664, 0x680, 0x3, 0x2, 0x2, 0x2, 0x665, 0x666, 0x7, 0x76, 
    0x2, 0x2, 0x666, 0x680, 0x8, 0x78, 0x1, 0x2, 0x667, 0x668, 0x5, 0xec, 
    0x77, 0x2, 0x668, 0x669, 0x8, 0x78, 0x1, 0x2, 0x669, 0x680, 0x3, 0x2, 
    0x2, 0x2, 0x66a, 0x66c, 0x7, 0x6, 0x2, 0x2, 0x66b, 0x66d, 0x5, 0xde, 
    0x70, 0x2, 0x66c, 0x66b, 0x3, 0x2, 0x2, 0x2, 0x66c, 0x66d, 0x3, 0x2, 
    0x2, 0x2, 0x66d, 0x66e, 0x3, 0x2, 0x2, 0x2, 0x66e, 0x66f, 0x7, 0x7, 
    0x2, 0x2, 0x66f, 0x680, 0x8, 0x78, 0x1, 0x2, 0x670, 0x672, 0x7, 0xa, 
    0x2, 0x2, 0x671, 0x673, 0x5, 0xe2, 0x72, 0x2, 0x672, 0x671, 0x3, 0x2, 
    0x2, 0x2, 0x672, 0x673, 0x3, 0x2, 0x2, 0x2, 0x673, 0x674, 0x3, 0x2, 
    0x2, 0x2, 0x674, 0x675, 0x7, 0xc, 0x2, 0x2, 0x675, 0x680, 0x8, 0x78, 
    0x1, 0x2, 0x676, 0x677, 0x6, 0x78, 0x26, 0x2, 0x677, 0x678, 0x7, 0x8, 
    0x2, 0x2, 0x678, 0x679, 0x5, 0xee, 0x78, 0x2, 0x679, 0x67a, 0x7, 0x9, 
    0x2, 0x2, 0x67a, 0x67b, 0x8, 0x78, 0x1, 0x2, 0x67b, 0x680, 0x3, 0x2, 
    0x2, 0x2, 0x67c, 0x67d, 0x5, 0xd8, 0x6d, 0x2, 0x67d, 0x67e, 0x8, 0x78, 
    0x1, 0x2, 0x67e, 0x680, 0x3, 0x2, 0x2, 0x2, 0x67f, 0x65e, 0x3, 0x2, 
    0x2, 0x2, 0x67f, 0x662, 0x3, 0x2, 0x2, 0x2, 0x67f, 0x665, 0x3, 0x2, 
    0x2, 0x2, 0x67f, 0x667, 0x3, 0x2, 0x2, 0x2, 0x67f, 0x66a, 0x3, 0x2, 
    0x2, 0x2, 0x67f, 0x670, 0x3, 0x2, 0x2, 0x2, 0x67f, 0x676, 0x3, 0x2, 
    0x2, 0x2, 0x67f, 0x67c, 0x3, 0x2, 0x2, 0x2, 0x680, 0x68c, 0x3, 0x2, 
    0x2, 0x2, 0x681, 0x684, 0xc, 0x6, 0x2, 0x2, 0x682, 0x683, 0x7, 0x2c, 
    0x2, 0x2, 0x683, 0x685, 0x5, 0xee, 0x78, 0x2, 0x684, 0x682, 0x3, 0x2, 
    0x2, 0x2, 0x685, 0x686, 0x3, 0x2, 0x2, 0x2, 0x686, 0x684, 0x3, 0x2, 
    0x2, 0x2, 0x686, 0x687, 0x3, 0x2, 0x2, 0x2, 0x687, 0x688, 0x3, 0x2, 
    0x2, 0x2, 0x688, 0x689, 0x8, 0x78, 0x1, 0x2, 0x689, 0x68b, 0x3, 0x2, 
    0x2, 0x2, 0x68a, 0x681, 0x3, 0x2, 0x2, 0x2, 0x68b, 0x68e, 0x3, 0x2, 
    0x2, 0x2, 0x68c, 0x68a, 0x3, 0x2, 0x2, 0x2, 0x68c, 0x68d, 0x3, 0x2, 
    0x2, 0x2, 0x68d, 0xef, 0x3, 0x2, 0x2, 0x2, 0x68e, 0x68c, 0x3, 0x2, 0x2, 
    0x2, 0x68f, 0x690, 0x5, 0xee, 0x78, 0x2, 0x690, 0x691, 0x5, 0xd0, 0x69, 
    0x2, 0x691, 0xf1, 0x3, 0x2, 0x2, 0x2, 0x692, 0x693, 0x5, 0xb4, 0x5b, 
    0x2, 0x693, 0x694, 0x7, 0x96, 0x2, 0x2, 0x694, 0x695, 0x5, 0xee, 0x78, 
    0x2, 0x695, 0xf3, 0x3, 0x2, 0x2, 0x2, 0x696, 0x69a, 0x5, 0xee, 0x78, 
    0x2, 0x697, 0x69a, 0x7, 0x51, 0x2, 0x2, 0x698, 0x69a, 0x5, 0xf2, 0x7a, 
    0x2, 0x699, 0x696, 0x3, 0x2, 0x2, 0x2, 0x699, 0x697, 0x3, 0x2, 0x2, 
    0x2, 0x699, 0x698, 0x3, 0x2, 0x2, 0x2, 0x69a, 0xf5, 0x3, 0x2, 0x2, 0x2, 
    0xaf, 0x101, 0x106, 0x10d, 0x113, 0x118, 0x11e, 0x12d, 0x134, 0x13c, 
    0x141, 0x143, 0x14a, 0x14f, 0x154, 0x158, 0x160, 0x16a, 0x16e, 0x174, 
    0x17a, 0x181, 0x187, 0x18f, 0x195, 0x19f, 0x1a5, 0x1a9, 0x1b2, 0x1b6, 
    0x1c2, 0x1d9, 0x1dd, 0x1e1, 0x1fc, 0x204, 0x230, 0x233, 0x249, 0x24d, 
    0x251, 0x25b, 0x260, 0x263, 0x267, 0x26a, 0x26e, 0x273, 0x278, 0x27b, 
    0x27f, 0x282, 0x285, 0x28d, 0x291, 0x295, 0x29e, 0x2a6, 0x2ae, 0x2b6, 
    0x2bd, 0x2c3, 0x2cc, 0x2d0, 0x2d7, 0x2dd, 0x2e1, 0x2e3, 0x2ea, 0x2f0, 
    0x2f7, 0x309, 0x316, 0x319, 0x31c, 0x31f, 0x324, 0x329, 0x32e, 0x331, 
    0x334, 0x338, 0x33d, 0x342, 0x348, 0x34b, 0x34e, 0x351, 0x355, 0x358, 
    0x35b, 0x361, 0x366, 0x370, 0x374, 0x381, 0x385, 0x392, 0x396, 0x39f, 
    0x3a7, 0x3ac, 0x3b4, 0x3b9, 0x3be, 0x3c3, 0x3c8, 0x3ce, 0x3d4, 0x3da, 
    0x3df, 0x3e3, 0x3e7, 0x3ed, 0x3f2, 0x3f9, 0x3fd, 0x40a, 0x40e, 0x428, 
    0x430, 0x434, 0x43b, 0x43f, 0x445, 0x44f, 0x452, 0x45e, 0x463, 0x46a, 
    0x48f, 0x493, 0x4a5, 0x4c9, 0x4ec, 0x4f2, 0x4f6, 0x556, 0x55a, 0x56c, 
    0x56f, 0x573, 0x575, 0x57b, 0x587, 0x590, 0x592, 0x598, 0x5b5, 0x5b9, 
    0x5bd, 0x5c1, 0x5ce, 0x5d4, 0x5de, 0x5ec, 0x5f2, 0x5fd, 0x606, 0x608, 
    0x60c, 0x616, 0x61f, 0x62c, 0x649, 0x656, 0x658, 0x65c, 0x66c, 0x672, 
    0x67f, 0x686, 0x68c, 0x699, 
  };

  atn::ATNDeserializer deserializer;
  _atn = deserializer.deserialize(_serializedATN);

  size_t count = _atn.getNumberOfDecisions();
  _decisionToDFA.reserve(count);
  for (size_t i = 0; i < count; i++) { 
    _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
  }
}

FormalParser::Initializer FormalParser::_init;
